pyRiemann: Biosignals classification with Riemannian geometry

pyRiemann is a Python machine learning package based on scikit-learn API. It provides a high-level interface for processing and classification of multivariate time series through the Riemannian geometry of symmetric positive definite (SPD) matrices.

pyRiemann aims at being a generic package for multivariate time series classification but has been designed around multichannel biosignals (like EEG, MEG or EMG) manipulation applied to brain-computer interface (BCI), transforming multichannel time series into covariance matrices, and classifying them using the Riemannian geometry of SPD matrices.

For a brief introduction to the ideas behind the package, you can read the introductory notes. More practical information is on the installation page. You may also want to browse the example gallery to get a sense for what you can do with pyRiemann and API reference to find out how.

To see the code or report a bug, please visit the github repository.

Content

Introduction to pyRiemann

What’s new in the package

A catalog of new features, improvements, and bug-fixes in each release.

v0.4 (Feb 2023)

• Add exponential and logarithmic maps for three main metrics: ‘euclid’, ‘logeuclid’ and ‘riemann’. pyriemann.utils.tangentspace.tangent_space() is splitted in two steps: (i) log_map_*() projecting SPD matrices into tangent space depending on the metric; and (ii) pyriemann.utils.tangentspace.upper() taking the upper triangular part of matrices. Similarly, pyriemann.utils.tangentspace.untangent_space() is splitted into (i) pyriemann.utils.tangentspace.unupper() and (ii) exp_map_*(). The different metrics for tangent space mapping can now be defined into pyriemann.tangentspace.TangentSpace, then used for transform() as well as for inverse_transform(). #195 by @qbarthelemy

• Enhance AJD: add init to pyriemann.utils.ajd.ajd_pham() and pyriemann.utils.ajd.rjd(), add warm_restart to pyriemann.spatialfilters.AJDC. #196 by @qbarthelemy

• Add parameter sampling_method to pyriemann.datasets.sample_gaussian_spd(), with rejection accelerating 2x2 matrices generation. #198 by @Artim436

• Add geometric medians for Euclidean and Riemannian metrics: pyriemann.utils.median_euclid() and pyriemann.utils.median_riemann(), and add an example in gallery to compare means and medians on synthetic datasets. #200 by @qbarthelemy

• Add score() to pyriemann.regression.KNearestNeighborRegressor. #205 by @qbarthelemy

• Add Transfer Learning module and examples, including RPA and MDWM. #189 by @plcrodrigues, @qbarthelemy and @sylvchev

• Add class distinctiveness function to measure the distinctiveness between classes on the manifold, pyriemann.classification.class_distinctiveness(), and complete an example in gallery to show how it works on synthetic datasets. #215 by @MSYamamoto

• Add example on ensemble learning applied to functional connectivity, and add pyriemann.utils.base.nearest_sym_pos_def(). #202 by @mccorsi and @sylvchev

• Add kernel matrices representation pyriemann.estimation.Kernels and complete example comparing estimators. #217 by @qbarthelemy

• Add a new covariance estimator, robust fixed point covariance, and add kwds arguments for all covariance based functions and classes. #220 by @qbarthelemy

• Add example in gallery on frequency band selection using class distinctiveness measure. #219 by @MSYamamoto

• Add pyriemann.utils.covariance.covariance_mest() supporting three robust M-estimators (Huber, Student-t and Tyler) and available for all covariance based functions and classes; and add an example on robust covariance estimation for corrupted data. Add also pyriemann.utils.distance.distance_mahalanobis() between between vectors and a Gaussian distribution. #223 by @qbarthelemy

v0.3 (July 2022)

• Correct spectral estimation in pyriemann.utils.covariance.cross_spectrum() to obtain equivalence with SciPy. #133 by @qbarthelemy

• Add instantaneous, lagged and imaginary coherences in pyriemann.utils.covariance.coherence() and pyriemann.estimation.Coherences. #132 by @qbarthelemy

• Add partial_fit in pyriemann.clustering.Potato, useful for an online update; and update example on artifact detection. #133 by @qbarthelemy

• Deprecate pyriemann.utils.viz.plot_confusion_matrix() as sklearn integrate its own version. #135 by @sylvchev

• Add Ando-Li-Mathias mean estimation in pyriemann.utils.mean.mean_covariance(). #56 by @sylvchev

• Add Schaefer-Strimmer covariance estimator in pyriemann.utils.covariance.covariances(), and an example to compare estimators #59 by @sylvchev

• Refactor tests + fix refit of pyriemann.tangentspace.TangentSpace. #136 by @sylvchev

• Add pyriemann.clustering.PotatoField, and an example on artifact detection. #142 by @qbarthelemy

• Add sampling SPD matrices from a Riemannian Gaussian distribution in pyriemann.datasets.sample_gaussian_spd(). #140 by @plcrodrigues

• Add new function pyriemann.datasets.make_gaussian_blobs() for generating random datasets with SPD matrices. #140 by @plcrodrigues

• Add module pyriemann.utils.viz in API, add pyriemann.utils.viz.plot_waveforms(), and add an example on ERP visualization. #144 by @qbarthelemy

• Add a special form covariance matrix pyriemann.utils.covariance.covariances_X(). #147 by @qbarthelemy

• Add masked and NaN means with Riemannian metric: pyriemann.utils.mean.maskedmean_riemann() and pyriemann.utils.mean.nanmean_riemann(). #149 by @qbarthelemy and @sylvchev

• Add corr option in pyriemann.utils.covariance.normalize(), to normalize covariance into correlation matrices. #153 by @qbarthelemy

• Add block covariance matrix: pyriemann.estimation.BlockCovariances and pyriemann.utils.covariance.block_covariances(). #154 by @gabelstein

• Add Riemannian Locally Linear Embedding: pyriemann.embedding.LocallyLinearEmbedding and pyriemann.embedding.locally_linear_embedding(). #159 by @gabelstein

• Add Riemannian Kernel Function: pyriemann.utils.kernel.kernel_riemann(). #159 by @gabelstein

• Fix fit in pyriemann.channelselection.ElectrodeSelection. #166 by @qbarthelemy

• Add power mean estimation in pyriemann.utils.mean.mean_power(). #170 by @qbarthelemy and @plcrodrigues

• Add example in gallery to compare classifiers on synthetic datasets. #175 by @qbarthelemy

• Add predict_proba in pyriemann.classification.KNearestNeighbor, and correct attribute classes_. #171 by @qbarthelemy

• Add Riemannian Support Vector Machine classifier: pyriemann.classification.SVC. #175 by @gabelstein and @qbarthelemy

• Add Riemannian Support Vector Machine regressor: pyriemann.regression.SVR. #175 by @gabelstein and @qbarthelemy

• Add K-Nearest-Neighbor regressor: pyriemann.regression.KNearestNeighborRegressor. #164 by @gabelstein, @qbarthelemy and @agramfort

• Add Minimum Distance to Mean Field classifier: pyriemann.classification.MeanField. #172 by @qbarthelemy and @plcrodrigues

• Add example on principal geodesic analysis (PGA) for SSVEP classification. #169 by @qbarthelemy

• Add pyriemann.utils.distance.distance_harmonic(), and sort functions by their names in code, doc and tests. #183 by @qbarthelemy

• Parallelize functions for dataset generation: pyriemann.datasets.make_gaussian_blobs(). #179 by @sylvchev

• Fix dispersion when generating datasets: pyriemann.datasets.sample_gaussian_spd(). #179 by @sylvchev

• Enhance base and distance functions, to process ndarrays of SPD matrices. #186 and #187 by @qbarthelemy

• Enhance utils functions, to process ndarrays of SPD matrices. #190 by @qbarthelemy

• Enhance means functions, with faster implementations and warning when convergence is not reached. #188 by @qbarthelemy

v0.2.7 (June 2021)

• Add example on SSVEP classification

• Fix compatibility with scikit-learn v0.24

• Correct probas of pyriemann.classification.MDM

• Add predict_proba for pyriemann.clustering.Potato, and an example on artifact detection

• Add weights to Pham’s AJD algorithm pyriemann.utils.ajd.ajd_pham()

• Add pyriemann.utils.covariance.cross_spectrum(), fix pyriemann.utils.covariance.cospectrum(); pyriemann.utils.covariance.coherence() output is kept unchanged

• Add pyriemann.spatialfilters.AJDC for BSS and gBSS, with an example on artifact correction

• Add pyriemann.preprocessing.Whitening, with optional dimension reduction

v0.2.6 (March 2020)

• Updated for better Scikit-Learn v0.22 support

v0.2.5 (January 2018)

• Added BilinearFilter

• Added a permutation test for generic scikit-learn estimator

• Stats module refactoring, with distance based t-test and f-test

• Removed two way permutation test

• Added FlatChannelRemover

• Support for python 3.5 in travis

• Added Shrinkage transformer

• Added Coherences transformer

• Added Embedding class.

v0.2.4 (June 2016)

• Improved documentation

• Added TSclassifier for out-of the box tangent space classification.

• Added Wasserstein distance and mean.

• Added NearestNeighbor classifier.

• Added Softmax probabilities for MDM.

• Added CSP for covariance matrices.

• Added Approximate Joint diagonalization algorithms (JADE, PHAM, UWEDGE).

• Added ALE mean.

• Added Multiclass CSP.

• API: param name changes in CospCovariances to comply to Scikit-Learn.

• API: attributes name changes in most modules to comply to the Scikit-Learn naming convention.

• Added HankelCovariances estimation

• Added SPoC spatial filtering

• Added Harmonic mean

• Added Kullback leibler mean

v0.2.3 (November 2015)

• Added multiprocessing for MDM with joblib.

• Added kullback-leibler divergence.

• Added Riemannian Potato.

• Added sample_weight for mean estimation and MDM.

Installing pyRiemann

The easiest way to install a stable version of pyRiemann is through pypi, the python package manager :

pip install pyriemann

For a bleeding edge version, you can clone the source code on github and install directly the package from source.

pip install -e .

The install script will install the required dependencies. If you want also to build the documentation and to run the test locally, you could install all development dependencies with

pip install -e .[docs,tests]

If you use a zsh shell, you need to write pip install -e .[docs,tests]. If you do not know what zsh is, you could use the above command.

Dependencies

• Python (>= 3.7)

Mandatory dependencies

• numpy

• scipy

• scikit-learn >=0.17

• pandas

• joblib

Recommended dependencies

These dependencies are recommanded to use the plotting functions of pyriemann or to run examples and tutorials, but they are not mandatory:

• mne-python

• matplotlib

• seaborn

Examples Gallery

Classification of ERP

Using Riemannian geometry for classifying event-related potentials (ERP).

Embedding ERP MEG data in 2D Euclidean space

Embedding ERP MEG data in 2D Euclidean space

Display ERP

Display ERP

ERP EEG decoding in Tangent space.

ERP EEG decoding in Tangent space.

Multiclass MEG ERP Decoding

Multiclass MEG ERP Decoding

Classification of SSVEP

Using Riemannian geometry for classifying steady-state visually evoked potentials (SSVEP).

Offline SSVEP-based BCI Multiclass Prediction

Offline SSVEP-based BCI Multiclass Prediction

Visualization of SSVEP-based BCI Classification in Tangent Space

Visualization of SSVEP-based BCI Classification in Tangent Space

Artifact management

Using Riemannian geometry to detect, reject or correct artifacts.

Artifact Correction by AJDC-based Blind Source Separation

Artifact Correction by AJDC-based Blind Source Separation

Online Artifact Detection with Riemannian Potato Field

Online Artifact Detection with Riemannian Potato Field

Online Artifact Detection with Riemannian Potato

Online Artifact Detection with Riemannian Potato

Classification of motor imagery

Using Riemannian geometry for classifying motor imagery.

Motor imagery classification

Motor imagery classification

Ensemble learning on functional connectivity

Ensemble learning on functional connectivity

Frequency band selection on the manifold for motor imagery classification

Frequency band selection on the manifold for motor imagery classification

Covariance estimation

Examples for covariance matrix estimation.

Robust covariance estimation

Robust covariance estimation

Compare covariance and kernel estimators with different time windows

Compare covariance and kernel estimators with different time windows

Simulated data

Examples using datasets sampled from known probability distributions.

Sample from the Riemannian Gaussian distribution in the SPD manifold

Sample from the Riemannian Gaussian distribution in the SPD manifold

Classification accuracy vs class distinctiveness vs class separability

Classification accuracy vs class distinctiveness vs class separability

Mean and median comparison

Mean and median comparison

Estimate mean of SPD matrices with NaN values

Estimate mean of SPD matrices with NaN values

Classifier comparison

Classifier comparison

Permutation test

Permutation test with pyRiemann.

One Way manova time

One Way manova time

One Way manova with Frequenty

One Way manova with Frequenty

One Way manova

One Way manova

Manova for ERP data

Manova for ERP data

Transfer learning

Using Riemannian geometry for transfer learning and domain adaptation.

Plot the data transformations in the Riemannian Procrustes Analysis

Plot the data transformations in the Riemannian Procrustes Analysis

Motor imagery classification by transfer learning

Motor imagery classification by transfer learning

Comparison of pipelines for transfer learning

Comparison of pipelines for transfer learning

Classification of ERP

Using Riemannian geometry for classifying event-related potentials (ERP).

Embedding ERP MEG data in 2D Euclidean space

Embedding ERP MEG data in 2D Euclidean space

Display ERP

Display ERP

ERP EEG decoding in Tangent space.

ERP EEG decoding in Tangent space.

Multiclass MEG ERP Decoding

Multiclass MEG ERP Decoding

Embedding ERP MEG data in 2D Euclidean space

Riemannian embeddings via Laplacian Eigenmaps (LE) and Locally Linear Embedding (LLE) of a set of ERP data. Embedding via Laplacian Eigenmaps is referred to as Spectral Embedding (SE).

Locally Linear Embedding (LLE) assumes that the local neighborhood of a point on the manifold can be well approximated by the affine subspace spanned by the k-nearest neighbors of the point and finds a low-dimensional embedding of the data based on these affine approximations.

Laplacian Eigenmaps (LE) are based on computing the low dimensional representation that best preserves locality instead of local linearity in LLE 1.

# Authors:  Pedro Rodrigues <pedro.rodrigues01@gmail.com>,
#           Gabriel Wagner vom Berg <gabriel@bccn-berlin.de>
# License: BSD (3-clause)

from pyriemann.estimation import XdawnCovariances
from pyriemann.utils.viz import plot_embedding

import mne
from mne import io
from mne.datasets import sample

from sklearn.model_selection import train_test_split

import matplotlib.pyplot as plt


print(__doc__)

Set parameters and read data

data_path = str(sample.data_path())
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
event_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif'
tmin, tmax = -0., 1
event_id = dict(aud_l=1, aud_r=2, vis_l=3, vis_r=4)

# Setup for reading the raw data
raw = io.Raw(raw_fname, preload=True, verbose=False)
raw.filter(2, None, method='iir')  # replace baselining with high-pass
events = mne.read_events(event_fname)

raw.info['bads'] = ['MEG 2443']  # set bad channels
picks = mne.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False,
                       exclude='bads')

# Read epochs
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=False,
                    picks=picks, baseline=None, preload=True, verbose=False)

X = epochs.get_data()
y = epochs.events[:, -1]

Filtering raw data in 1 contiguous segment
Setting up high-pass filter at 2 Hz

IIR filter parameters
---------------------
Butterworth highpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 8 (effective, after forward-backward)
- Cutoff at 2.00 Hz: -6.02 dB

Embedding of Xdawn covariance matrices

nfilter = 4
xdwn = XdawnCovariances(estimator='scm', nfilter=nfilter)
split = train_test_split(X, y, train_size=0.25, random_state=42)
Xtrain, Xtest, ytrain, ytest = split
covs = xdwn.fit(Xtrain, ytrain).transform(Xtest)

Laplacian Eigenmaps (LE), also called Spectral Embedding (SE)

plot_embedding(covs, ytest, metric='riemann', embd_type='Spectral',
               normalize=True)
plt.show()

Locally Linear Embedding (LLE)

plot_embedding(covs, ytest, metric='riemann', embd_type='LocallyLinear',
               normalize=False)
plt.show()

References

1

Clustering and dimensionality reduction on Riemannian manifolds A. Goh and R Vidal, in 2008 IEEE Conference on Computer Vision and Pattern Recognition.

Display ERP

Different ways to display a multichannel event-related potential (ERP).

# Authors: Quentin Barthélemy
#
# License: BSD (3-clause)

import numpy as np
import mne
from matplotlib import pyplot as plt
from pyriemann.utils.viz import plot_waveforms

Load EEG data

# Set filenames
data_path = str(mne.datasets.sample.data_path())
raw_fname = data_path + "/MEG/sample/sample_audvis_filt-0-40_raw.fif"
event_fname = data_path + "/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif"

# Read raw data, select occipital channels and high-pass filter signal
raw = mne.io.Raw(raw_fname, preload=True, verbose=False)
raw.pick_channels(['EEG 057', 'EEG 058', 'EEG 059'], ordered=True)
raw.rename_channels({'EEG 057': 'O1', 'EEG 058': 'Oz', 'EEG 059': 'O2'})
n_channels = len(raw.ch_names)
raw.filter(1.0, None, method="iir")

# Read epochs and get responses to left visual field stimulus
tmin, tmax = -0.1, 0.8
epochs = mne.Epochs(
    raw, mne.read_events(event_fname), {'vis_l': 3}, tmin, tmax, proj=False,
    baseline=None, preload=True, verbose=False)
X = 5e5 * epochs.get_data()
print('Number of trials:', X.shape[0])
times = np.linspace(tmin, tmax, num=X.shape[2])

plt.rcParams["figure.figsize"] = (7, 12)
ylims = []

Removing projector <Projection | PCA-v1, active : False, n_channels : 102>
Removing projector <Projection | PCA-v2, active : False, n_channels : 102>
Removing projector <Projection | PCA-v3, active : False, n_channels : 102>
Filtering raw data in 1 contiguous segment
Setting up high-pass filter at 1 Hz

IIR filter parameters
---------------------
Butterworth highpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 8 (effective, after forward-backward)
- Cutoff at 1.00 Hz: -6.02 dB

Number of trials: 73

Plot all trials

This kind of plot is a little bit messy.

fig = plot_waveforms(X, 'all', times=times, alpha=0.3)
fig.suptitle('Plot all trials', fontsize=16)
for i_channel in range(n_channels):
    fig.axes[i_channel].set(ylabel=raw.ch_names[i_channel])
    fig.axes[i_channel].set_xlim(tmin, tmax)
    ylims.append(fig.axes[i_channel].get_ylim())
fig.axes[n_channels - 1].set(xlabel='Time')
plt.show()

Plot central tendency and dispersion of trials

This kind of plot is well-spread, but mean and standard deviation can be contaminated by artifacts, and they make a symmetric assumption on amplitude distribution.

fig = plot_waveforms(X, 'mean+/-std', times=times)
fig.suptitle('Plot mean+/-std of trials', fontsize=16)
for i_channel in range(n_channels):
    fig.axes[i_channel].set(ylabel=raw.ch_names[i_channel])
    fig.axes[i_channel].set_xlim(tmin, tmax)
    fig.axes[i_channel].set_ylim(ylims[i_channel])
fig.axes[n_channels - 1].set(xlabel='Time')
plt.show()

Plot histogram of trials

This plot estimates a 2D histogram of trials 1.

fig = plot_waveforms(X, 'hist', times=times, n_bins=25, cmap=plt.cm.Greys)
fig.suptitle('Plot histogram of trials', fontsize=16)
for i_channel in range(n_channels):
    fig.axes[i_channel].set(ylabel=raw.ch_names[i_channel])
    fig.axes[i_channel].set_ylim(ylims[i_channel])
fig.axes[n_channels - 1].set(xlabel='Time')
plt.show()

References

1

Improved estimation of EEG evoked potentials by jitter compensation and enhancing spatial filters A. Souloumiac and B. Rivet. 2013 IEEE International Conference on Acoustics, Speech and Signal Processing.

ERP EEG decoding in Tangent space.

Decoding applied to EEG data in sensor space decomposed using Xdawn. After spatial filtering, covariances matrices are estimated, then projected in the tangent space and classified with a logistic regression.

# Authors: Alexandre Barachant <alexandre.barachant@gmail.com>
#
# License: BSD (3-clause)

import numpy as np

from pyriemann.estimation import XdawnCovariances
from pyriemann.tangentspace import TangentSpace

import mne
from mne import io
from mne.datasets import sample

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import KFold
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
from sklearn.pipeline import make_pipeline

from matplotlib import pyplot as plt

print(__doc__)

Set parameters and read data

data_path = str(sample.data_path())
raw_fname = data_path + "/MEG/sample/sample_audvis_filt-0-40_raw.fif"
event_fname = data_path + "/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif"
tmin, tmax = -0.0, 1
event_id = dict(aud_l=1, aud_r=2, vis_l=3, vis_r=4)

# Setup for reading the raw data
raw = io.Raw(raw_fname, preload=True, verbose=False)
raw.filter(2, None, method="iir")  # replace baselining with high-pass
events = mne.read_events(event_fname)

raw.info["bads"] = ["MEG 2443"]  # set bad channels
picks = mne.pick_types(
    raw.info, meg=False, eeg=True, stim=False, eog=False, exclude="bads"
)

# Read epochs
epochs = mne.Epochs(
    raw,
    events,
    event_id,
    tmin,
    tmax,
    proj=False,
    picks=picks,
    baseline=None,
    preload=True,
    verbose=False,
)

labels = epochs.events[:, -1]
evoked = epochs.average()

Filtering raw data in 1 contiguous segment
Setting up high-pass filter at 2 Hz

IIR filter parameters
---------------------
Butterworth highpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 8 (effective, after forward-backward)
- Cutoff at 2.00 Hz: -6.02 dB

Removing projector <Projection | PCA-v1, active : False, n_channels : 102>
Removing projector <Projection | PCA-v2, active : False, n_channels : 102>
Removing projector <Projection | PCA-v3, active : False, n_channels : 102>

Decoding in tangent space with a logistic regression

n_components = 2  # pick some components

# Define a monte-carlo cross-validation generator (reduce variance):
cv = KFold(n_splits=10, shuffle=True, random_state=42)
epochs_data = epochs.get_data()


clf = make_pipeline(
    XdawnCovariances(n_components),
    TangentSpace(metric="riemann"),
    LogisticRegression(),
)

preds = np.zeros(len(labels))

for train_idx, test_idx in cv.split(epochs_data):
    y_train, y_test = labels[train_idx], labels[test_idx]

    clf.fit(epochs_data[train_idx], y_train)
    preds[test_idx] = clf.predict(epochs_data[test_idx])

# Printing the results
acc = np.mean(preds == labels)
print("Classification accuracy: %f " % (acc))

names = ["audio left", "audio right", "vis left", "vis right"]
cm = confusion_matrix(labels, preds)
ConfusionMatrixDisplay(cm, display_labels=names).plot()
plt.show()

Classification accuracy: 0.750000

Multiclass MEG ERP Decoding

Decoding applied to MEG data in sensor space decomposed using Xdawn. After spatial filtering, covariances matrices are estimated and classified by the MDM algorithm (Nearest centroid).

4 Xdawn spatial patterns (1 for each class) are displayed, as per the for mean-covariance matrices used by the classification algorithm.

# Authors: Alexandre Barachant <alexandre.barachant@gmail.com>
#
# License: BSD (3-clause)

import numpy as np
from matplotlib import pyplot as plt
from pyriemann.estimation import XdawnCovariances
from pyriemann.classification import MDM

import mne
from mne import io
from mne.datasets import sample

from sklearn.metrics import (
    classification_report,
    confusion_matrix,
    ConfusionMatrixDisplay,
)
from sklearn.model_selection import KFold
from sklearn.pipeline import make_pipeline

print(__doc__)

Set parameters and read data

data_path = str(sample.data_path())
raw_fname = data_path + "/MEG/sample/sample_audvis_filt-0-40_raw.fif"
event_fname = data_path + "/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif"
tmin, tmax = -0.0, 1
event_id = dict(aud_l=1, aud_r=2, vis_l=3, vis_r=4)

# Setup for reading the raw data
raw = io.Raw(raw_fname, preload=True)
raw.filter(2, None, method="iir")  # replace baselining with high-pass
events = mne.read_events(event_fname)

raw.info["bads"] = ["MEG 2443"]  # set bad channels
picks = mne.pick_types(
    raw.info, meg="grad", eeg=False, stim=False, eog=False, exclude="bads"
)

# Read epochs
epochs = mne.Epochs(
    raw,
    events,
    event_id,
    tmin,
    tmax,
    proj=False,
    picks=picks,
    baseline=None,
    preload=True,
    verbose=False,
)

labels = epochs.events[:, -1]
evoked = epochs.average()

Opening raw data file /home/docs/mne_data/MNE-sample-data/MEG/sample/sample_audvis_filt-0-40_raw.fif...
    Read a total of 4 projection items:
        PCA-v1 (1 x 102)  idle
        PCA-v2 (1 x 102)  idle
        PCA-v3 (1 x 102)  idle
        Average EEG reference (1 x 60)  idle
    Range : 6450 ... 48149 =     42.956 ...   320.665 secs
Ready.
Reading 0 ... 41699  =      0.000 ...   277.709 secs...
Filtering raw data in 1 contiguous segment
Setting up high-pass filter at 2 Hz

IIR filter parameters
---------------------
Butterworth highpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 8 (effective, after forward-backward)
- Cutoff at 2.00 Hz: -6.02 dB

Removing projector <Projection | PCA-v1, active : False, n_channels : 102>
Removing projector <Projection | PCA-v2, active : False, n_channels : 102>
Removing projector <Projection | PCA-v3, active : False, n_channels : 102>
Removing projector <Projection | Average EEG reference, active : False, n_channels : 60>

Decoding with Xdawn + MDM

n_components = 3  # pick some components

# Define a monte-carlo cross-validation generator (reduce variance):
cv = KFold(n_splits=10, shuffle=True, random_state=42)
pr = np.zeros(len(labels))
epochs_data = epochs.get_data()

print("Multiclass classification with XDAWN + MDM")

clf = make_pipeline(XdawnCovariances(n_components), MDM())

for train_idx, test_idx in cv.split(epochs_data):
    y_train, y_test = labels[train_idx], labels[test_idx]

    clf.fit(epochs_data[train_idx], y_train)
    pr[test_idx] = clf.predict(epochs_data[test_idx])

print(classification_report(labels, pr))

Multiclass classification with XDAWN + MDM
              precision    recall  f1-score   support

           1       0.89      0.93      0.91        72
           2       0.90      0.89      0.90        73
           3       0.92      0.96      0.94        73
           4       0.97      0.90      0.93        70

    accuracy                           0.92       288
   macro avg       0.92      0.92      0.92       288
weighted avg       0.92      0.92      0.92       288

plot the spatial patterns

xd = XdawnCovariances(n_components)
xd.fit(epochs_data, labels)

info = evoked.copy().resample(1).info  # make it 1Hz for plotting
patterns = mne.EvokedArray(
    data=xd.Xd_.patterns_.T, info=info
)
patterns.plot_topomap(
    times=[0, n_components, 2 * n_components, 3 * n_components],
    ch_type="grad",
    colorbar=False,
    size=1.5,
    time_format="Pattern %d"
)

<MNEFigure size 900x287.5 with 4 Axes>

plot the confusion matrix

names = ["audio left", "audio right", "vis left", "vis right"]
cm = confusion_matrix(labels, pr)
ConfusionMatrixDisplay(cm, display_labels=names).plot()
plt.show()

Classification of SSVEP

Using Riemannian geometry for classifying steady-state visually evoked potentials (SSVEP).

Offline SSVEP-based BCI Multiclass Prediction

Offline SSVEP-based BCI Multiclass Prediction

Visualization of SSVEP-based BCI Classification in Tangent Space

Visualization of SSVEP-based BCI Classification in Tangent Space

Offline SSVEP-based BCI Multiclass Prediction

Building extended covariance matrices for SSVEP-based BCI. The obtained matrices are shown. A Minimum Distance to Mean classifier is trained to predict a 4-class problem for an offline setup.

# Authors: Sylvain Chevallier <sylvain.chevallier@uvsq.fr>,
# Emmanuel Kalunga, Quentin Barthélemy, David Ojeda
#
# License: BSD (3-clause)

import numpy as np
import matplotlib.pyplot as plt

from mne import find_events, Epochs
from mne.io import Raw
from sklearn.model_selection import cross_val_score, RepeatedKFold

from pyriemann.estimation import BlockCovariances
from pyriemann.utils.mean import mean_riemann
from pyriemann.classification import MDM
from helpers.ssvep_helpers import download_data, extend_signal

Loading EEG data

The data are loaded through a MNE loader

# Download data
destination = download_data(subject=12, session=1)
# Read data in MNE Raw and numpy format
raw = Raw(destination, preload=True, verbose='ERROR')
events = find_events(raw, shortest_event=0, verbose=False)
raw = raw.pick_types(eeg=True)

event_id = {'13 Hz': 2, '17 Hz': 4, '21 Hz': 3, 'resting-state': 1}
sfreq = int(raw.info['sfreq'])
eeg_data = raw.get_data()

Using default location ~/mne_data for ssvep...

  0%|                                              | 0.00/3.33M [00:00<?, ?B/s]
  1%|▎                                     | 31.7k/3.33M [00:00<00:15, 216kB/s]
  2%|▋                                     | 64.5k/3.33M [00:00<00:14, 219kB/s]
  4%|█▌                                     | 130k/3.33M [00:00<00:09, 322kB/s]
  6%|██▎                                    | 196k/3.33M [00:00<00:08, 370kB/s]
  8%|███                                    | 261k/3.33M [00:00<00:07, 396kB/s]
 10%|███▊                                   | 327k/3.33M [00:00<00:07, 412kB/s]
 12%|████▌                                  | 392k/3.33M [00:01<00:06, 422kB/s]
 14%|█████▎                                 | 458k/3.33M [00:01<00:06, 429kB/s]
 16%|██████▏                                | 523k/3.33M [00:01<00:06, 433kB/s]
 18%|██████▉                                | 589k/3.33M [00:01<00:06, 435kB/s]
 20%|███████▋                               | 654k/3.33M [00:01<00:06, 437kB/s]
 22%|████████▍                              | 720k/3.33M [00:01<00:05, 438kB/s]
 24%|█████████▏                             | 785k/3.33M [00:01<00:05, 440kB/s]
 26%|█████████▉                             | 851k/3.33M [00:02<00:05, 440kB/s]
 28%|██████████▋                            | 916k/3.33M [00:02<00:05, 440kB/s]
 30%|███████████▌                           | 982k/3.33M [00:02<00:05, 440kB/s]
 31%|███████████▉                          | 1.05M/3.33M [00:02<00:05, 440kB/s]
 33%|████████████▋                         | 1.11M/3.33M [00:02<00:05, 440kB/s]
 35%|█████████████▍                        | 1.18M/3.33M [00:02<00:04, 440kB/s]
 37%|██████████████▏                       | 1.24M/3.33M [00:02<00:04, 440kB/s]
 39%|██████████████▉                       | 1.31M/3.33M [00:03<00:04, 440kB/s]
 41%|███████████████▋                      | 1.38M/3.33M [00:03<00:04, 441kB/s]
 43%|████████████████▎                     | 1.42M/3.33M [00:03<00:04, 408kB/s]
 45%|█████████████████                     | 1.49M/3.33M [00:03<00:04, 418kB/s]
 46%|█████████████████▌                    | 1.54M/3.33M [00:03<00:04, 392kB/s]
 48%|██████████████████▏                   | 1.59M/3.33M [00:03<00:04, 374kB/s]
 50%|██████████████████▉                   | 1.65M/3.33M [00:04<00:04, 395kB/s]
 52%|███████████████████▋                  | 1.72M/3.33M [00:04<00:03, 409kB/s]
 54%|████████████████████▍                 | 1.78M/3.33M [00:04<00:03, 419kB/s]
 56%|█████████████████████▏                | 1.85M/3.33M [00:04<00:03, 426kB/s]
 58%|█████████████████████▊                | 1.92M/3.33M [00:04<00:03, 430kB/s]
 60%|██████████████████████▌               | 1.98M/3.33M [00:04<00:03, 433kB/s]
 62%|███████████████████████▎              | 2.05M/3.33M [00:04<00:02, 433kB/s]
 63%|████████████████████████              | 2.11M/3.33M [00:05<00:02, 436kB/s]
 65%|████████████████████████▊             | 2.18M/3.33M [00:05<00:02, 437kB/s]
 67%|█████████████████████████▌            | 2.24M/3.33M [00:05<00:02, 438kB/s]
 69%|██████████████████████████▎           | 2.31M/3.33M [00:05<00:02, 440kB/s]
 71%|██████████████████████████▉           | 2.36M/3.33M [00:05<00:02, 408kB/s]
 73%|███████████████████████████▋          | 2.42M/3.33M [00:05<00:02, 417kB/s]
 75%|████████████████████████████▍         | 2.49M/3.33M [00:05<00:01, 425kB/s]
 77%|█████████████████████████████▏        | 2.55M/3.33M [00:06<00:01, 430kB/s]
 79%|█████████████████████████████▉        | 2.62M/3.33M [00:06<00:01, 434kB/s]
 80%|██████████████████████████████▍       | 2.67M/3.33M [00:06<00:01, 403kB/s]
 82%|███████████████████████████████▏      | 2.74M/3.33M [00:06<00:01, 415kB/s]
 84%|███████████████████████████████▉      | 2.80M/3.33M [00:06<00:01, 423kB/s]
 86%|████████████████████████████████▋     | 2.87M/3.33M [00:06<00:01, 428kB/s]
 88%|█████████████████████████████████▍    | 2.93M/3.33M [00:06<00:00, 433kB/s]
 90%|██████████████████████████████████▏   | 3.00M/3.33M [00:07<00:00, 435kB/s]
 92%|██████████████████████████████████▉   | 3.06M/3.33M [00:07<00:00, 437kB/s]
 94%|███████████████████████████████████▋  | 3.13M/3.33M [00:07<00:00, 438kB/s]
 95%|████████████████████████████████████▎ | 3.18M/3.33M [00:07<00:00, 407kB/s]
 97%|█████████████████████████████████████ | 3.24M/3.33M [00:07<00:00, 417kB/s]
 99%|█████████████████████████████████████▊| 3.31M/3.33M [00:07<00:00, 424kB/s]
  0%|                                              | 0.00/3.33M [00:00<?, ?B/s]
100%|█████████████████████████████████████| 3.33M/3.33M [00:00<00:00, 6.26GB/s]
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/examples/SSVEP/helpers/ssvep_helpers.py:79: RuntimeWarning: Setting non-standard config type: "MNE_DATASETS_SSVEPEXO_PATH"
  data_path = fetch_dataset(dataset_params, force_update=True)

Visualization of raw EEG data

Plot few seconds of signal from the Oz electrode using matplotlib

n_seconds = 2
time = np.linspace(0, n_seconds, n_seconds * sfreq,
                   endpoint=False)[np.newaxis, :]
plt.figure(figsize=(10, 4))
plt.plot(time.T, eeg_data[np.array(raw.ch_names) == 'Oz', :n_seconds*sfreq].T,
         color='C0', lw=0.5)
plt.xlabel("Time (s)")
plt.ylabel(r"Oz ($\mu$V)")
plt.show()

And of all electrodes:

plt.figure(figsize=(10, 4))
for ch_idx, ch_name in enumerate(raw.ch_names):
    plt.plot(time.T, eeg_data[ch_idx, :n_seconds*sfreq].T, lw=0.5,
             label=ch_name)
plt.xlabel("Time (s)")
plt.ylabel(r"EEG ($\mu$V)")
plt.legend(loc='upper right')
plt.show()

With MNE, it is much easier to visualize the data

raw.plot(duration=n_seconds, start=0, n_channels=8, scalings={'eeg': 4e-2},
         color={'eeg': 'steelblue'})

Using matplotlib as 2D backend.

<MNEBrowseFigure size 800x800 with 4 Axes>

Extended signals for spatial covariance

Using the approach proposed by 1, the SSVEP signal is extended to include the filtered signals for each stimulation frequency. We stack the filtered signals to build an extended signal.

# We stack the filtered signals to build an extended signal
frequencies = [13, 17, 21]
freq_band = 0.1
raw_ext = extend_signal(raw, frequencies, freq_band)

Creating RawArray with float64 data, n_channels=24, n_times=92384
    Range : 0 ... 92383 =      0.000 ...   360.871 secs
Ready.

Plot the extended signal

raw_ext.plot(duration=n_seconds, start=14, n_channels=24,
             scalings={'eeg': 5e-4}, color={'eeg': 'steelblue'})

<MNEBrowseFigure size 800x800 with 4 Axes>

Building Epochs and plotting 3 s of the signal from electrode Oz for a trial

epochs = Epochs(raw_ext, events, event_id, tmin=2, tmax=5, baseline=None)

n_seconds = 3
time = np.linspace(0, n_seconds, n_seconds * sfreq,
                   endpoint=False)[np.newaxis, :]
channels = range(0, len(raw_ext.ch_names), len(raw.ch_names))
plt.figure(figsize=(7, 5))
for f, c in zip(frequencies, channels):
    plt.plot(epochs.get_data()[5, c, :].T, label=str(int(f))+' Hz')
plt.xlabel("Time (s)")
plt.ylabel(r"Oz after filtering ($\mu$V)")
plt.legend(loc='upper right')
plt.show()

Not setting metadata
32 matching events found
No baseline correction applied
0 projection items activated
Using data from preloaded Raw for 32 events and 769 original time points ...
0 bad epochs dropped
Using data from preloaded Raw for 32 events and 769 original time points ...
Using data from preloaded Raw for 32 events and 769 original time points ...

As it can be seen on this example, the subject is watching the 13Hz stimulation and the EEG activity is showing an increase activity in this frequency band while other frequencies have lower amplitudes.

Spatial covariance for SSVEP

The covariance matrices will be estimated using the Ledoit-Wolf shrinkage estimator on the extended signal.

cov_ext_trials = BlockCovariances(estimator='lwf',
                                  block_size=8).transform(epochs.get_data())

# This plot shows an example of a covariance matrix observed for each class:
ch_names = raw_ext.info['ch_names']

plt.figure(figsize=(7, 7))
for i, l in enumerate(event_id):
    ax = plt.subplot(2, 2, i+1)
    plt.imshow(cov_ext_trials[events[:, 2] == event_id[l]][0],
               cmap=plt.get_cmap('RdBu_r'))
    plt.title('Cov for class: '+l)
    plt.xticks([])
    if i == 0 or i == 2:
        plt.yticks(np.arange(len(ch_names)), ch_names)
        ax.tick_params(axis='both', which='major', labelsize=7)
    else:
        plt.yticks([])
plt.show()

Using data from preloaded Raw for 32 events and 769 original time points ...

It appears clearly that each class yields a different structure of the covariance matrix. Each stimulation (13, 17 and 21 Hz) generating higher covariance values for EEG signal filtered at the proper bandwith and no activation at all for the other bandwiths. The resting state, where the subject focus on the center of the display and far from all blinking stimulus, shows an activity with higher correlation in the 13Hz frequency and lower but still visible activity in the other bandwiths.

Classify with MDM

Plotting mean of each class

cov_centers = np.empty((len(event_id), 24, 24))
for i, l in enumerate(event_id):
    cov_centers[i] = mean_riemann(cov_ext_trials[events[:, 2] == event_id[l]])

plt.figure(figsize=(7, 7))
for i, l in enumerate(event_id):
    ax = plt.subplot(2, 2, i+1)
    plt.imshow(cov_centers[i], cmap=plt.get_cmap('RdBu_r'))
    plt.title('Cov mean for class: '+l)
    plt.xticks([])
    if i == 0 or i == 2:
        plt.yticks(np.arange(len(ch_names)), ch_names)
        ax.tick_params(axis='both', which='major', labelsize=7)
    else:
        plt.yticks([])
plt.show()

Minimum distance to mean is a simple and robust algorithm for BCI decoding. It reproduces results of 2 for the first session of subject 12.

print("Number of trials: {}".format(len(cov_ext_trials)))

cv = RepeatedKFold(n_splits=2, n_repeats=10, random_state=42)
mdm = MDM(metric=dict(mean='riemann', distance='riemann'))
scores = cross_val_score(mdm, cov_ext_trials, events[:, 2], cv=cv, n_jobs=1)
print("MDM accuracy: {:.2f}% +/- {:.2f}".format(np.mean(scores)*100,
                                                np.std(scores)*100))
# The obtained results are 80.62% +/- 16.29 for this session, with a repeated
# 10-fold validation.

Number of trials: 32
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
MDM accuracy: 80.94% +/- 16.23

References

1

A New generation of Brain-Computer Interface Based on Riemannian Geometry M. Congedo, A. Barachant, A. Andreev. Research report, 2013.

2

Review of Riemannian distances and divergences, applied to SSVEP-based BCI S. Chevallier, E. K. Kalunga, Q. Barthélemy, E. Monacelli. Neuroinformatics, Springer, 2021, 19 (1), pp.93-106

Visualization of SSVEP-based BCI Classification in Tangent Space

Project extended covariance matrices of SSVEP-based BCI in the tangent space, using principal geodesic analysis (PGA).

You should have a look to “Offline SSVEP-based BCI Multiclass Prediction” before this example.

# Authors: Quentin Barthélemy, Emmanuel Kalunga and Sylvain Chevallier
#
# License: BSD (3-clause)

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

from mne import find_events, Epochs, make_fixed_length_epochs
from mne.io import Raw
from sklearn.pipeline import make_pipeline
from sklearn.decomposition import PCA

from pyriemann.estimation import BlockCovariances
from pyriemann.classification import MDM
from pyriemann.tangentspace import TangentSpace
from pyriemann.utils.viz import _add_alpha
from helpers.ssvep_helpers import download_data, extend_signal

clabel = ['resting-state', '13 Hz', '17 Hz', '21 Hz']
clist = plt.cm.viridis(np.array([0, 1, 2, 3])/3)
cmap = "viridis"


def plot_pga(ax, data, labels, centers):
    sc = ax.scatter(data[:, 0], data[:, 1], c=labels, marker='P', cmap=cmap)
    ax.scatter(
        centers[:, 0], centers[:, 1], c=clist, marker='o', s=100, cmap=cmap
        )
    ax.set(xlabel='PGA, 1st axis', ylabel='PGA, 2nd axis')
    for i in range(len(clabel)):
        ax.scatter([], [], color=clist[i], marker='o', s=50, label=clabel[i])
    ax.legend(loc='upper right')
    return sc

Load EEG and extract covariance matrices for SSVEP

frequencies = [13, 17, 21]
freq_band = 0.1
events_id = {'13 Hz': 2, '17 Hz': 4, '21 Hz': 3, 'resting-state': 1}

duration = 2.5    # duration of epochs
interval = 0.25   # interval between successive epochs for online processing

# Subject 12: first 4 sessions for training, last session for test

# Training set
raw = Raw(download_data(subject=12, session=1), preload=True, verbose=False)
events = find_events(raw, shortest_event=0, verbose=False)
raw = raw.pick_types(eeg=True)
ch_count = len(raw.info['ch_names'])
raw_ext = extend_signal(raw, frequencies, freq_band)
epochs = Epochs(
    raw_ext, events, events_id, tmin=2, tmax=5, baseline=None, verbose=False)
x_train = BlockCovariances(
    estimator='lwf', block_size=ch_count).transform(epochs.get_data())
y_train = events[:, 2]

# Testing set
raw = Raw(download_data(subject=12, session=4), preload=True, verbose=False)
raw = raw.pick_types(eeg=True)
raw_ext = extend_signal(raw, frequencies, freq_band)
epochs = make_fixed_length_epochs(
    raw_ext, duration=duration, overlap=duration - interval, verbose=False)
x_test = BlockCovariances(
    estimator='lwf', block_size=ch_count).transform(epochs.get_data())

Creating RawArray with float64 data, n_channels=24, n_times=92384
    Range : 0 ... 92383 =      0.000 ...   360.871 secs
Ready.
Using data from preloaded Raw for 32 events and 769 original time points ...
0 bad epochs dropped

  0%|                                              | 0.00/5.35M [00:00<?, ?B/s]
  1%|▏                                     | 31.7k/5.35M [00:00<00:24, 216kB/s]
  1%|▍                                     | 64.5k/5.35M [00:00<00:24, 219kB/s]
  2%|▉                                      | 130k/5.35M [00:00<00:16, 322kB/s]
  4%|█▍                                     | 196k/5.35M [00:00<00:13, 370kB/s]
  5%|█▉                                     | 261k/5.35M [00:00<00:12, 396kB/s]
  6%|██▍                                    | 327k/5.35M [00:00<00:12, 412kB/s]
  7%|██▊                                    | 392k/5.35M [00:01<00:11, 422kB/s]
  9%|███▎                                   | 458k/5.35M [00:01<00:11, 429kB/s]
 10%|███▊                                   | 523k/5.35M [00:01<00:11, 433kB/s]
 11%|████▎                                  | 589k/5.35M [00:01<00:10, 436kB/s]
 12%|████▊                                  | 654k/5.35M [00:01<00:10, 438kB/s]
 13%|█████▏                                 | 720k/5.35M [00:01<00:10, 439kB/s]
 15%|█████▋                                 | 785k/5.35M [00:01<00:10, 440kB/s]
 16%|██████▏                                | 851k/5.35M [00:02<00:10, 441kB/s]
 17%|██████▋                                | 916k/5.35M [00:02<00:10, 441kB/s]
 18%|███████▏                               | 982k/5.35M [00:02<00:09, 440kB/s]
 20%|███████▍                              | 1.05M/5.35M [00:02<00:09, 441kB/s]
 21%|███████▉                              | 1.11M/5.35M [00:02<00:09, 441kB/s]
 22%|████████▎                             | 1.18M/5.35M [00:02<00:09, 441kB/s]
 23%|████████▊                             | 1.24M/5.35M [00:02<00:09, 440kB/s]
 24%|█████████▎                            | 1.31M/5.35M [00:03<00:09, 440kB/s]
 26%|█████████▊                            | 1.38M/5.35M [00:03<00:09, 441kB/s]
 27%|██████████▏                           | 1.44M/5.35M [00:03<00:08, 441kB/s]
 28%|██████████▋                           | 1.51M/5.35M [00:03<00:08, 442kB/s]
 29%|███████████                           | 1.56M/5.35M [00:03<00:09, 409kB/s]
 30%|███████████▌                          | 1.62M/5.35M [00:03<00:08, 419kB/s]
 31%|███████████▊                          | 1.67M/5.35M [00:04<00:09, 393kB/s]
 32%|████████████▎                         | 1.74M/5.35M [00:04<00:08, 407kB/s]
 34%|████████████▊                         | 1.80M/5.35M [00:04<00:08, 417kB/s]
 35%|█████████████▎                        | 1.87M/5.35M [00:04<00:08, 424kB/s]
 36%|█████████████▋                        | 1.93M/5.35M [00:04<00:07, 429kB/s]
 37%|██████████████▏                       | 2.00M/5.35M [00:04<00:07, 433kB/s]
 38%|██████████████▌                       | 2.05M/5.35M [00:04<00:08, 403kB/s]
 39%|███████████████                       | 2.11M/5.35M [00:05<00:07, 414kB/s]
 41%|███████████████▍                      | 2.18M/5.35M [00:05<00:07, 423kB/s]
 42%|███████████████▉                      | 2.24M/5.35M [00:05<00:07, 428kB/s]
 43%|████████████████▍                     | 2.31M/5.35M [00:05<00:07, 432kB/s]
 44%|████████████████▊                     | 2.37M/5.35M [00:05<00:06, 435kB/s]
 46%|█████████████████▎                    | 2.44M/5.35M [00:05<00:06, 437kB/s]
 47%|█████████████████▊                    | 2.51M/5.35M [00:05<00:06, 437kB/s]
 48%|██████████████████▎                   | 2.57M/5.35M [00:06<00:06, 438kB/s]
 49%|██████████████████▌                   | 2.62M/5.35M [00:06<00:06, 406kB/s]
 50%|███████████████████                   | 2.69M/5.35M [00:06<00:06, 417kB/s]
 51%|███████████████████▌                  | 2.75M/5.35M [00:06<00:06, 424kB/s]
 53%|████████████████████                  | 2.82M/5.35M [00:06<00:05, 429kB/s]
 54%|████████████████████▍                 | 2.88M/5.35M [00:06<00:05, 433kB/s]
 55%|████████████████████▉                 | 2.95M/5.35M [00:06<00:05, 435kB/s]
 56%|█████████████████████▍                | 3.01M/5.35M [00:07<00:05, 437kB/s]
 58%|█████████████████████▊                | 3.08M/5.35M [00:07<00:05, 438kB/s]
 58%|██████████████████████▏               | 3.13M/5.35M [00:07<00:05, 407kB/s]
 59%|██████████████████████▌               | 3.18M/5.35M [00:07<00:05, 384kB/s]
 61%|███████████████████████               | 3.24M/5.35M [00:07<00:05, 401kB/s]
 62%|███████████████████████▍              | 3.31M/5.35M [00:07<00:04, 414kB/s]
 63%|███████████████████████▉              | 3.37M/5.35M [00:08<00:04, 421kB/s]
 64%|████████████████████████▍             | 3.44M/5.35M [00:08<00:04, 427kB/s]
 65%|████████████████████████▊             | 3.49M/5.35M [00:08<00:04, 399kB/s]
 66%|█████████████████████████▏            | 3.55M/5.35M [00:08<00:04, 411kB/s]
 67%|█████████████████████████▌            | 3.60M/5.35M [00:08<00:04, 388kB/s]
 68%|█████████████████████████▉            | 3.65M/5.35M [00:08<00:04, 371kB/s]
 69%|██████████████████████████▎           | 3.70M/5.35M [00:08<00:04, 360kB/s]
 70%|██████████████████████████▊           | 3.77M/5.35M [00:09<00:04, 384kB/s]
 72%|███████████████████████████▏          | 3.83M/5.35M [00:09<00:03, 401kB/s]
 73%|███████████████████████████▋          | 3.90M/5.35M [00:09<00:03, 413kB/s]
 74%|████████████████████████████▏         | 3.96M/5.35M [00:09<00:03, 421kB/s]
 75%|████████████████████████████▌         | 4.01M/5.35M [00:09<00:03, 395kB/s]
 76%|████████████████████████████▊         | 4.06M/5.35M [00:09<00:03, 376kB/s]
 77%|█████████████████████████████▏        | 4.11M/5.35M [00:09<00:03, 363kB/s]
 78%|█████████████████████████████▋        | 4.18M/5.35M [00:10<00:03, 387kB/s]
 79%|██████████████████████████████▏       | 4.24M/5.35M [00:10<00:02, 403kB/s]
 80%|██████████████████████████████▍       | 4.29M/5.35M [00:10<00:02, 382kB/s]
 81%|██████████████████████████████▉       | 4.36M/5.35M [00:10<00:02, 400kB/s]
 83%|███████████████████████████████▍      | 4.42M/5.35M [00:10<00:02, 413kB/s]
 84%|███████████████████████████████▉      | 4.49M/5.35M [00:10<00:02, 421kB/s]
 85%|████████████████████████████████▎     | 4.55M/5.35M [00:10<00:01, 428kB/s]
 86%|████████████████████████████████▊     | 4.62M/5.35M [00:11<00:01, 432kB/s]
 87%|█████████████████████████████████▏    | 4.67M/5.35M [00:11<00:01, 402kB/s]
 88%|█████████████████████████████████▌    | 4.73M/5.35M [00:11<00:01, 414kB/s]
 90%|██████████████████████████████████    | 4.80M/5.35M [00:11<00:01, 422kB/s]
 91%|██████████████████████████████████▌   | 4.87M/5.35M [00:11<00:01, 428kB/s]
 92%|███████████████████████████████████   | 4.93M/5.35M [00:11<00:00, 432kB/s]
 93%|███████████████████████████████████▍  | 5.00M/5.35M [00:12<00:00, 434kB/s]
 95%|███████████████████████████████████▉  | 5.06M/5.35M [00:12<00:00, 437kB/s]
 96%|████████████████████████████████████▍ | 5.13M/5.35M [00:12<00:00, 438kB/s]
 97%|████████████████████████████████████▉ | 5.19M/5.35M [00:12<00:00, 439kB/s]
 98%|█████████████████████████████████████▎| 5.26M/5.35M [00:12<00:00, 439kB/s]
100%|█████████████████████████████████████▊| 5.32M/5.35M [00:12<00:00, 441kB/s]
  0%|                                              | 0.00/5.35M [00:00<?, ?B/s]
100%|█████████████████████████████████████| 5.35M/5.35M [00:00<00:00, 16.4GB/s]
Creating RawArray with float64 data, n_channels=24, n_times=148544
    Range : 0 ... 148543 =      0.000 ...   580.246 secs
Ready.
Using data from preloaded Raw for 2312 events and 640 original time points ...
0 bad epochs dropped

Classification with minimum distance to mean (MDM)

Classification for a 4-class SSVEP BCI, including resting-state class.

print("Number of training trials: {}".format(len(x_train)))

mdm = MDM(metric=dict(mean='riemann', distance='riemann'))
mdm.fit(x_train, y_train)

Number of training trials: 32

MDM(metric={'distance': 'riemann', 'mean': 'riemann'})

Projection in tangent space with principal geodesic analysis (PGA)

Project covariance matrices from the Riemannian manifold into the Euclidean tangent space at the grand average, and apply a principal component analysis (PCA) to obtain an unsupervised dimension reduction 1.

pga = make_pipeline(
    TangentSpace(metric="riemann", tsupdate=False),
    PCA(n_components=2)
)

ts_train = pga.fit_transform(x_train)
ts_means = pga.transform(np.array(mdm.covmeans_))

Offline training of MDM visualized by PGA

These figures show the trajectory on the tangent space taken by covariance matrices during a 4-class SSVEP experiment, and how they are classified epoch by epoch.

This figure reproduces Fig 3(c) of reference 2, showing training trials of best subject.

fig, ax = plt.subplots(figsize=(8, 8))
fig.suptitle('PGA of training set', fontsize=16)
plot_pga(ax, ts_train, y_train, ts_means)
plt.show()

Online classification by MDM visualized by PGA

This figure reproduces Fig 6 of reference 2, with an animation to imitate an online acquisition, processing and classification of EEG time-series.

Warning: 2 uses a curved based online classification, while a single trial classification is used here.

# Prepare data for online classification
test_visu = 50     # nb of matrices to display simultaneously
colors, ts_visu = [], np.empty([0, 2])
alphas = np.linspace(0, 1, test_visu)

fig, ax = plt.subplots(figsize=(8, 8))
fig.suptitle('PGA of testing set', fontsize=16)
pl = plot_pga(ax, ts_visu, colors, ts_means)
pl.axes.set_xlim(-5, 6)
pl.axes.set_ylim(-5, 5)

(-5.0, 5.0)

# Prepare animation for online classification
def online_classify(t):
    global colors, ts_visu

    # Online classification
    y = mdm.predict(x_test[np.newaxis, t])
    color = clist[int(y[0] - 1)]
    ts_test = pga.transform(x_test[np.newaxis, t])

    # Update data
    colors.append(color)
    ts_visu = np.vstack((ts_visu, ts_test))
    if len(ts_visu) > test_visu:
        colors.pop(0)
        ts_visu = ts_visu[1:]
    colors = _add_alpha(colors, alphas)

    # Update plot
    pl.set_offsets(np.c_[ts_visu[:, 0], ts_visu[:, 1]])
    pl.set_color(colors)
    return pl


interval_display = 1.0  # can be changed for a slower display

visu = FuncAnimation(fig, online_classify,
                     frames=range(0, len(x_test)),
                     interval=interval_display, blit=False, repeat=False)

# Plot online classification

# Plot complete visu: a dynamic display is required
plt.show()

# Plot only 10s, for animated documentation
try:
    from IPython.display import HTML
except ImportError:
    raise ImportError("Install IPython to plot animation in documentation")

plt.rcParams["animation.embed_limit"] = 10
HTML(visu.to_jshtml(fps=5, default_mode='loop'))

Animation size has reached 10525072 bytes, exceeding the limit of 10485760.0. If you're sure you want a larger animation embedded, set the animation.embed_limit rc parameter to a larger value (in MB). This and further frames will be dropped.

Once Loop Reflect

References

1

Principal geodesic analysis for the study of nonlinear statistics of shape P.T. Fletcher, C. Lu, S. M. Pizer, S. Joshi. IEEE Transactions on Medical Imaging (Volume: 23, Issue: 8, August 2004).

2(1,2,3)

Online SSVEP-based BCI using Riemannian geometry E. K. Kalunga, S. Chevallier, Q. Barthélemy, K. Djouani, E. Monacelli, Y. Hamam. Neurocomputing, Elsevier, 2016, 191, pp.55-68.

Artifact management

Using Riemannian geometry to detect, reject or correct artifacts.

Artifact Correction by AJDC-based Blind Source Separation

Artifact Correction by AJDC-based Blind Source Separation

Online Artifact Detection with Riemannian Potato Field

Online Artifact Detection with Riemannian Potato Field

Online Artifact Detection with Riemannian Potato

Online Artifact Detection with Riemannian Potato

Artifact Correction by AJDC-based Blind Source Separation

Blind source separation (BSS) based on approximate joint diagonalization of Fourier cospectra (AJDC), applied to artifact correction of EEG 1.

# Authors: Quentin Barthélemy & David Ojeda.
# EEG signal kindly shared by Marco Congedo.
#
# License: BSD (3-clause)

import gzip
import numpy as np
from scipy.signal import welch
from matplotlib import pyplot as plt

from mne import create_info
from mne.io import RawArray
from mne.viz import plot_topomap
from mne.preprocessing import ICA

from pyriemann.spatialfilters import AJDC
from pyriemann.utils.viz import plot_cospectra

def read_header(fname):
    """Read the header of sample-blinks.txt"""
    with gzip.open(fname, 'rt') as f:
        content = f.readline().split()
        return content[:-1], int(content[-1])

Load EEG data

fname = '../data/sample-blinks.txt.gz'
signal_raw = np.loadtxt(fname, skiprows=1).T
ch_names, sfreq = read_header(fname)
ch_count = len(ch_names)
duration = signal_raw.shape[1] / sfreq

Channel space

# Plot signal X
ch_info = create_info(ch_names=ch_names, ch_types=['eeg'] * ch_count,
                      sfreq=sfreq)
ch_info.set_montage('standard_1020')
signal = RawArray(signal_raw, ch_info, verbose=False)
signal.plot(duration=duration, start=0, n_channels=ch_count,
            scalings={'eeg': 3e1}, color={'eeg': 'steelblue'},
            title='Original EEG signal', show_scalebars=False)

<MNEBrowseFigure size 800x800 with 4 Axes>

AJDC: Second-Order Statistics (SOS)-based BSS, diagonalizing cospectra

# Compute and diagonalize Fourier cospectral matrices between 1 and 32 Hz
window, overlap = sfreq, 0.5
fmin, fmax = 1, 32
ajdc = AJDC(window=window, overlap=overlap, fmin=fmin, fmax=fmax, fs=sfreq,
            dim_red={'max_cond': 100})
ajdc.fit(signal_raw[np.newaxis, np.newaxis, ...])
freqs = ajdc.freqs_

# Plot cospectra in channel space, after trace-normalization by frequency: each
# cospectrum, associated to a frequency, is a covariance matrix
plot_cospectra(ajdc._cosp_channels, freqs, ylabels=ch_names,
               title='Cospectra, in channel space')

Condition numbers:
 array([  1.        ,   2.29766117,   4.09457756,   4.86981696,
         6.09760458,   9.15865458,  13.21748535,  17.74436118,
        26.1024296 ,  27.31744246,  33.78134725,  45.22515539,
        50.61007053,  60.36895283,  73.48533473,  74.73247287,
        92.15600097, 121.30282659, 164.52162547])
Dimension reduction of Whitening on 17 components

<Figure size 1200x700 with 32 Axes>

# Plot diagonalized cospectra in source space
sr_count = ajdc.n_sources_
sr_names = ['S' + str(s).zfill(2) for s in range(sr_count)]
plot_cospectra(ajdc._cosp_sources, freqs, ylabels=sr_names,
               title='Diagonalized cospectra, in source space')

<Figure size 1200x700 with 32 Axes>

Source space

# Estimate sources S applying forward filters B to signal X: S = B X
source_raw = ajdc.transform(signal_raw[np.newaxis, ...])[0]

# Plot sources S
sr_info = create_info(ch_names=sr_names, ch_types=['misc'] * sr_count,
                      sfreq=sfreq)
source = RawArray(source_raw, sr_info, verbose=False)
source.plot(duration=duration, start=0, n_channels=sr_count,
            scalings={'misc': 2e2}, title='EEG sources estimated by AJDC',
            show_scalebars=False)

<MNEBrowseFigure size 800x800 with 4 Axes>

Artifact identification

# Identify artifact by eye: blinks are well separated in source S0
blink_idx = 0

# Get normal spectrum, ie power spectrum after trace-normalization
blink_spectrum_norm = ajdc._cosp_sources[:, blink_idx, blink_idx]
blink_spectrum_norm /= np.linalg.norm(blink_spectrum_norm)

# Get absolute spectrum, ie raw power spectrum of the source
f, spectrum = welch(source.get_data(picks=[blink_idx]), fs=sfreq,
                    nperseg=window, noverlap=int(window * overlap))
blink_spectrum_abs = spectrum[0, (f >= fmin) & (f <= fmax)]
blink_spectrum_abs /= np.linalg.norm(blink_spectrum_abs)

# Get topographic map
blink_filter = ajdc.backward_filters_[:, blink_idx]

# Plot spectrum and topographic map of the blink source separated by AJDC
fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(12, 5))
axs[0].set(title='Power spectrum of the blink source estimated by AJDC',
           xlabel='Frequency (Hz)', ylabel='Power spectral density')
axs[0].plot(freqs, blink_spectrum_abs, label='Absolute power')
axs[0].plot(freqs, blink_spectrum_norm, label='Normal power')
axs[0].legend()
axs[1].set_title('Topographic map of the blink source estimated by AJDC')
plot_topomap(blink_filter, pos=ch_info, axes=axs[1], extrapolate='box')
plt.show()

Artifact correction by BSS denoising

# BSS denoising: blink source is suppressed in source space using activation
# matrix D, and then applying backward filters A to come back to channel space
# Denoised signal: Xd = A D S
signal_denois_raw = ajdc.inverse_transform(source_raw[np.newaxis, ...],
                                           supp=[blink_idx])[0]

# Plot denoised signal Xd
signal_denois = RawArray(signal_denois_raw, ch_info, verbose=False)
signal_denois.plot(duration=duration, start=0, n_channels=ch_count,
                   scalings={'eeg': 3e1}, color={'eeg': 'steelblue'},
                   title='Denoised EEG signal by AJDC', show_scalebars=False)

<MNEBrowseFigure size 800x800 with 4 Axes>

Comparison with Independent Component Analysis (ICA)

# Infomax-based ICA is a Higher-Order Statistics (HOS)-based BSS, minimizing
# mutual information
ica = ICA(n_components=ajdc.n_sources_, method='infomax', random_state=42)
ica.fit(signal, picks='eeg')

# Plot sources separated by ICA
ica.plot_sources(signal, title='EEG sources estimated by ICA')

# Can you find the blink source?

/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/examples/artifacts/plot_correct_ajdc_EEG.py:162: RuntimeWarning: The data has not been high-pass filtered. For good ICA performance, it should be high-pass filtered (e.g., with a 1.0 Hz lower bound) before fitting ICA.
  ica.fit(signal, picks='eeg')
Fitting ICA to data using 19 channels (please be patient, this may take a while)
Selecting by number: 17 components

Fitting ICA took 0.3s.
Creating RawArray with float64 data, n_channels=17, n_times=1408
    Range : 0 ... 1407 =      0.000 ...    10.992 secs
Ready.

<MNEBrowseFigure size 800x800 with 4 Axes>

# Plot topographic maps of sources separated by ICA
ica.plot_components(title='Topographic maps of EEG sources estimated by ICA')

[<MNEFigure size 975x967 with 17 Axes>]

References

1

Online denoising of eye-blinks in electroencephalography Q. Barthélemy, L. Mayaud, Y. Renard, D. Kim, S.-W. Kang, J. Gunkelman and M. Congedo. Clinical Neurophysiology, Elsevier Masson, 2017, 47 (5-6), pp.371-391

Online Artifact Detection with Riemannian Potato Field

Example of Riemannian Potato Field (RPF) 1 applied on EEG time-series to detect artifacts in online processing. It is compared to the Riemannian Potato (RP) 2.

# Authors: Quentin Barthélemy
#
# License: BSD (3-clause)

import numpy as np
from matplotlib import pyplot as plt
from matplotlib.animation import FuncAnimation

from mne.datasets import eegbci
from mne.io import read_raw_edf
from mne.channels import make_standard_montage
from mne import make_fixed_length_epochs

from pyriemann.estimation import Covariances
from pyriemann.utils.covariance import normalize
from pyriemann.clustering import Potato, PotatoField

def filter_bandpass(signal, low_freq, high_freq, channels=None, method="iir"):
    """Filter signal on specific channels and in a specific frequency band"""
    sig = signal.copy()
    if channels is not None:
        sig.pick_channels(channels)
    sig.filter(l_freq=low_freq, h_freq=high_freq, method=method, verbose=False)
    return sig


def plot_detection(ax, rp_label, rpf_label):
    labels = []
    ylims = ax.get_ylim()
    height = ylims[1] - ylims[0]
    if not rp_label:
        r1 = ax.axhspan(
            ylims[0] + 0.06 * height, ylims[1] - 0.05 * height,
            edgecolor='r', facecolor='none',
            xmin=-test_time_start / test_duration - 0.005,
            xmax=(duration - test_time_start) / test_duration - 0.005)
        labels.append(r1)
        ax.text(0.25, 0.95, 'RP', color='r', size=16, transform=ax.transAxes)
    if not rpf_label:
        r2 = ax.axhspan(
            ylims[0] + 0.05 * height, ylims[1] - 0.06 * height,
            edgecolor='m', facecolor='none',
            xmin=-test_time_start / test_duration + 0.005,
            xmax=(duration - test_time_start) / test_duration + 0.005)
        labels.append(r2)
        ax.text(0.65, 0.95, 'RPF', color='m', size=16, transform=ax.transAxes)
    if rp_label and rpf_label:
        r3 = ax.axhspan(
            ylims[0] + 0.05 * height, ylims[1] - 0.05 * height,
            edgecolor='k', facecolor='none',
            xmin=-test_time_start / test_duration,
            xmax=(duration - test_time_start) / test_duration)
        labels.append(r3)
    return labels

Load EEG data

# Load motor imagery data
raw = read_raw_edf(eegbci.load_data(2, [5])[0], preload=True, verbose=False)
eegbci.standardize(raw)
raw.set_montage(make_standard_montage('standard_1005'))
sfreq = int(raw.info['sfreq'])  # 160 Hz

# Select the 21 channels of the 10-20 montage
raw.pick_channels(
    ['Fp1', 'Fpz', 'Fp2', 'F7', 'F3', 'Fz', 'F4', 'F8', 'T7', 'C3', 'Cz', 'C4',
     'T8', 'P7', 'P3', 'Pz', 'P4', 'P8', 'O1', 'Oz', 'O2'], ordered=True)
ch_names = raw.ch_names
ch_count = len(ch_names)

# Define time-series epoching with a sliding window
duration = 2.5    # duration of epochs
interval = 0.2    # interval between epochs

Riemannian potato

Riemannian potato (RP) 2 selects all channels and filter between 1 and 35 Hz.

# RP definition
z_th = 2.0           # z-score threshold
low_freq, high_freq = 1., 35.
rp = Potato(metric='riemann', threshold=z_th)

# EEG processing for RP
rp_sig = filter_bandpass(raw, low_freq, high_freq)  # band-pass filter
rp_epochs = make_fixed_length_epochs(  # epoch time-series
    rp_sig, duration=duration, overlap=duration - interval, verbose=False)
rp_covs = Covariances(estimator='scm').transform(rp_epochs.get_data())

# RP training
train_covs = 45      # nb of matrices for training
train_set = range(train_covs)
rp.fit(rp_covs[train_set])

Using data from preloaded Raw for 603 events and 400 original time points ...
0 bad epochs dropped

Potato(threshold=2.0)

Riemannian potato field

Riemannian potato field (RPF) 1 combines several potatoes of low dimensionality, each one designed to capture a different kind of artifact typically affecting some specific spatial area (i.e. subsets of channels) and/or specific frequency bands.

BCI or NFB applications aim at the modulation specific brain oscillations, it is thus advisable to exclude such frequencies from potatoes so as to prevent desirable brain modulations to be detected as artifactual.

# RPF definition
p_th = 0.01          # probability threshold
rpf_config = {
    'RPF eye_blinks': {  # for eye-blinks
        'ch_names': ['Fp1', 'Fpz', 'Fp2'],
        'low_freq': 1.,
        'high_freq': 20.},
    'RPF occipital': {  # for high-frequency artifacts in occipital area
        'ch_names': ['O1', 'Oz', 'O2'],
        'low_freq': 25.,
        'high_freq': 45.,
        'cov_normalization': 'trace'},  # trace-norm to be insensitive to power
    'RPF global_lf': {  # for low-frequency artifacts in all channels
        'ch_names': None,
        'low_freq': 0.5,
        'high_freq': 3.}
}
rpf = PotatoField(metric='riemann', z_threshold=z_th, p_threshold=p_th,
                  n_potatoes=len(rpf_config))

# EEG processing for RPF
rpf_covs = []
for p in rpf_config.values():  # loop on potatoes
    rpf_sig = filter_bandpass(raw, p.get('low_freq'), p.get('high_freq'),
                              channels=p.get('ch_names'))
    rpf_epochs = make_fixed_length_epochs(
        rpf_sig, duration=duration, overlap=duration - interval, verbose=False)
    covs_ = Covariances(estimator='scm').transform(rpf_epochs.get_data())
    if p.get('cov_normalization'):
        covs_ = normalize(covs_, p.get('cov_normalization'))
    rpf_covs.append(covs_)

# RPF training
rpf.fit([c[train_set] for c in rpf_covs])

Using data from preloaded Raw for 603 events and 400 original time points ...
0 bad epochs dropped
Using data from preloaded Raw for 603 events and 400 original time points ...
0 bad epochs dropped
Using data from preloaded Raw for 603 events and 400 original time points ...
0 bad epochs dropped
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')

PotatoField(n_potatoes=3, z_threshold=2.0)

Online Artifact Detection with Potatoes

Detect artifacts/outliers on test set, with an animation to imitate an online acquisition, processing and artifact detection of EEG time-series. Remark that all these potatoes are semi-dynamic: they are updated when EEG is not artifacted 1.

# Prepare data for online detection
test_covs_max = 400     # nb of epochs to visualize in this example
test_covs_visu = 100    # nb of z-scores/proba to display simultaneously
test_time_start = -2    # start time to display signal
test_time_end = 5       # end time to display signal

test_duration = test_time_end - test_time_start
time_start = train_covs * interval + test_time_start
time_end = train_covs * interval + test_time_end
time = np.linspace(time_start, time_end, int((time_end - time_start) * sfreq),
                   endpoint=False)
raw.filter(l_freq=0.5, h_freq=75., method='iir', verbose=False)
eeg_data = 1e5 * raw.get_data()
sig = eeg_data[:, int(time_start * sfreq):int(time_end * sfreq)]
eeg_offset = - 15 * np.linspace(1, ch_count, ch_count, endpoint=False)
covs_t, covs_z = np.empty([0]), np.empty([len(rpf_config) + 1, 0])
covs_p = np.empty([0])

fig, ax = plt.subplots(figsize=(12, 10), nrows=2, ncols=1)
fig.suptitle('Online artifact detection, RP vs RPF', fontsize=16)
ax[0].set(xlabel='Time (s)', ylabel='EEG channels')
ax[0].set_xlim([time[0], time[-1]])
ax[0].set_yticks(eeg_offset)
ax[0].set_yticklabels(ch_names)
pl = ax[0].plot(time, sig.T + eeg_offset.T, lw=0.75)
labels = []

ax[1].set(ylabel='Z-scores of distances to references')
pl2 = ax[1].plot(covs_t, covs_z.T, lw=0.75)
for c, l in enumerate(['RP'] + [*rpf_config]):
    pl2[c].set_label(l)
ax[1].set_ylim([-1.5, 8.5])
ax[1].legend(loc='upper left')
axp = ax[1].twinx()
axp.set(ylabel='RPF probability of clean EEG')
pl3 = axp.plot(covs_t, covs_p, lw=0.75, c='k', label='RPF proba')
axp.set_ylim([0, 1])
axp.legend(loc='upper right')

<matplotlib.legend.Legend object at 0x7fdae497dd10>

# Prepare animation for online detection
def online_detect(t):
    global time, sig, labels, covs_t, covs_z, covs_p

    # Online artifact detection
    rp_label = rp.predict(rp_covs[np.newaxis, t])[0]
    rp_zscore = rp.transform(rp_covs[np.newaxis, t])
    rpf_label = rpf.predict([c[np.newaxis, t] for c in rpf_covs])[0]
    rpf_zscores = rpf.transform([c[np.newaxis, t] for c in rpf_covs])
    rpf_proba = rpf.predict_proba([c[np.newaxis, t] for c in rpf_covs])
    if rp_label == 1:
        rp.partial_fit(rp_covs[np.newaxis, t], alpha=1 / t)
    if rpf_label == 1:
        rpf.partial_fit([c[np.newaxis, t] for c in rpf_covs], alpha=1 / t)

    # Update data
    time_start = t * interval + test_time_end
    time_end = (t + 1) * interval + test_time_end
    time_ = np.linspace(time_start, time_end, int(interval * sfreq),
                        endpoint=False)
    time = np.r_[time[int(interval * sfreq):], time_]
    sig = np.hstack((sig[:, int(interval * sfreq):],
                     eeg_data[:, int(time_start*sfreq):int(time_end*sfreq)]))
    covs_t = np.r_[covs_t, time_start]
    covs_z = np.hstack((covs_z,
                        np.vstack((rp_zscore[np.newaxis], rpf_zscores.T))))
    covs_p = np.r_[covs_p, rpf_proba]
    if len(covs_p) > test_covs_visu:
        covs_t, covs_z, covs_p = covs_t[1:], covs_z[:, 1:], covs_p[1:]

    # Update plot
    for c in range(ch_count):
        pl[c].set_data(time, sig[c] + eeg_offset[c])
        pl[c].axes.set_xlim(time[0], time[-1])
    for lbl in labels:
        lbl.remove()
    for txt in ax[0].texts:
        txt.set_visible(False)
    labels = plot_detection(ax[0], rp_label, rpf_label)
    for c in range(len(pl2)):
        pl2[c].set_data(covs_t, covs_z[c])
        pl2[c].axes.set_xlim(covs_t[0] - 0.1, covs_t[-1])
    pl3[0].set_data(covs_t, covs_p)
    return pl, pl2, pl3


interval_display = 1.0  # can be changed for a slower display

potato = FuncAnimation(fig, online_detect,
                       frames=range(train_covs, test_covs_max),
                       interval=interval_display, blit=False, repeat=False)

# Plot online detection

# Plot complete visu: a dynamic display is required
plt.show()

# Plot only 10s, for animated documentation
try:
    from IPython.display import HTML
except ImportError:
    raise ImportError("Install IPython to plot animation in documentation")

plt.rcParams["animation.embed_limit"] = 10
HTML(potato.to_jshtml(fps=5, default_mode='loop'))

Animation size has reached 10958720 bytes, exceeding the limit of 10485760.0. If you're sure you want a larger animation embedded, set the animation.embed_limit rc parameter to a larger value (in MB). This and further frames will be dropped.

Once Loop Reflect

References

1(1,2,3)

The Riemannian Potato Field: A Tool for Online Signal Quality Index of EEG Q. Barthélemy, L. Mayaud, D. Ojeda, and M. Congedo. IEEE Transactions on Neural Systems and Rehabilitation Engineering, IEEE Institute of Electrical and Electronics Engineers, 2019, 27 (2), pp.244-255

2(1,2)

The Riemannian Potato: an automatic and adaptive artifact detection method for online experiments using Riemannian geometry A. Barachant, A Andreev, and M. Congedo. TOBI Workshop lV, Jan 2013, Sion, Switzerland. pp.19-20.

Online Artifact Detection with Riemannian Potato

Example of Riemannian Potato 1 applied on EEG time-series to detect artifacts in online processing. It is computed only for two channels to display intuitive visualizations.

# Authors: Quentin Barthélemy & David Ojeda
#
# License: BSD (3-clause)

from functools import partial

import os

import numpy as np
from matplotlib import pyplot as plt
from matplotlib.animation import FuncAnimation

from mne.datasets import sample
from mne.io import read_raw_fif
from mne import make_fixed_length_epochs

from pyriemann.estimation import Covariances
from pyriemann.clustering import Potato
from pyriemann.utils.viz import _add_alpha

@partial(np.vectorize, excluded=['potato'])
def get_zscores(cov_00, cov_01, cov_11, potato):
    cov = np.array([[cov_00, cov_01], [cov_01, cov_11]])
    with np.testing.suppress_warnings() as sup:
        sup.filter(RuntimeWarning)
        return potato.transform(cov[np.newaxis, ...])


def plot_potato_2D(ax, cax, X, Y, p_zscores, p_center, covs, p_colors, clabel):
    qcs = ax.contourf(X, Y, p_zscores, levels=20, vmin=p_zscores.min(),
                      vmax=p_zscores.max(), cmap='RdYlBu_r', alpha=0.5)
    ax.contour(X, Y, p_zscores, levels=[z_th], colors='k')
    sc = ax.scatter(covs[:, 0, 0], covs[:, 1, 1], c=p_colors)
    ax.scatter(p_center[0, 0], p_center[1, 1], c='k', s=100)
    if cax:
        cbar = fig.colorbar(qcs, cax=cax)
    else:
        cbar = fig.colorbar(qcs, ax=ax)
    cbar.ax.set_ylabel(clabel)
    return sc


def plot_sig(ax, time, sig):
    ax.axis((time[0], time[-1], -15, 15))
    pl, = ax.plot(time, sig, lw=0.75)
    ax.axhspan(
        -14, 14, edgecolor='k', facecolor='none',
        xmin=-test_time_start / (test_time_end - test_time_start),
        xmax=(duration - test_time_start) / (test_time_end - test_time_start))
    return pl

Load EEG data

raw_fname = os.path.join(sample.data_path(), 'MEG', 'sample',
                         'sample_audvis_filt-0-40_raw.fif')
raw = read_raw_fif(raw_fname, preload=True, verbose=False)
sfreq = int(raw.info['sfreq'])  # 150 Hz

Offline processing of EEG data

# Apply common average reference on EEG channels
raw.pick_types(meg=False, eeg=True).apply_proj()

# Select two EEG channels for the example, preferably without artifact at the
# beginning, to have a reliable calibration
ch_names = ['EEG 010', 'EEG 015']

# Apply band-pass filter between 1 and 35 Hz
raw.filter(1., 35., method='iir', picks=ch_names)

# Epoch time-series with a sliding window
duration = 2.5    # duration of epochs
interval = 0.2    # interval between successive epochs
epochs = make_fixed_length_epochs(
    raw, duration=duration, overlap=duration - interval, verbose=False)
epochs_data = 5e5 * epochs.get_data(picks=ch_names)

# Estimate spatial covariance matrices
covs = Covariances(estimator='lwf').transform(epochs_data)

Removing projector <Projection | PCA-v1, active : False, n_channels : 102>
Removing projector <Projection | PCA-v2, active : False, n_channels : 102>
Removing projector <Projection | PCA-v3, active : False, n_channels : 102>
Created an SSP operator (subspace dimension = 1)
1 projection items activated
SSP projectors applied...
Filtering a subset of channels. The highpass and lowpass values in the measurement info will not be updated.
Filtering raw data in 1 contiguous segment
Setting up band-pass filter from 1 - 35 Hz

IIR filter parameters
---------------------
Butterworth bandpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 16 (effective, after forward-backward)
- Cutoffs at 1.00, 35.00 Hz: -6.02, -6.02 dB

Using data from preloaded Raw for 1377 events and 375 original time points ...
0 bad epochs dropped

Offline Calibration of Potato

2D projection of the z-score map of the Riemannian potato, for 2x2 covariance matrices (in blue if clean, in red if artifacted) and their reference matrix (in black). The colormap defines the z-score and a chosen isocontour defines the potato. It reproduces Fig 1 of reference 2.

z_th = 2.0       # z-score threshold
train_covs = 40  # nb of matrices to train the potato

# Calibrate potato by unsupervised training on first matrices: compute a
# reference matrix, mean and standard deviation of distances to this reference.
train_set = range(train_covs)
rpotato = Potato(metric='riemann', threshold=z_th).fit(covs[train_set])
rp_center = rpotato._mdm.covmeans_[0]
epotato = Potato(metric='euclid', threshold=z_th).fit(covs[train_set])
ep_center = epotato._mdm.covmeans_[0]

rp_labels = rpotato.predict(covs[train_set])
rp_colors = ['b' if ll == 1 else 'r' for ll in rp_labels.tolist()]
ep_labels = epotato.predict(covs[train_set])
ep_colors = ['b' if ll == 1 else 'r' for ll in ep_labels.tolist()]

# Zscores in the horizontal 2D plane going through the reference
X, Y = np.meshgrid(np.linspace(1, 31, 100), np.linspace(1, 31, 100))
rp_zscores = get_zscores(X, np.full_like(X, rp_center[0, 1]), Y,
                         potato=rpotato)
rp_mzscores = np.ma.masked_where(~np.isfinite(rp_zscores), rp_zscores)
ep_zscores = get_zscores(X, np.full_like(X, ep_center[0, 1]), Y,
                         potato=epotato)

# Plot calibration
xlabel = 'Cov({},{})'.format(ch_names[0], ch_names[0])
ylabel = 'Cov({},{})'.format(ch_names[1], ch_names[1])

fig, axs = plt.subplots(figsize=(12, 5), nrows=1, ncols=2)
fig.suptitle('Offline calibration of potatoes', fontsize=16)
axs[0].set(xlabel=xlabel, ylabel=ylabel,
           title='2D projection of Riemannian potato')
plot_potato_2D(axs[0], None, X, Y, rp_mzscores, rp_center, covs[train_set],
               rp_colors, 'Z-score of Riemannian distance to reference')
axs[1].set(xlabel=xlabel, ylabel=ylabel,
           title='2D projection of Euclidean potato')
plot_potato_2D(axs[1], None, X, Y, ep_zscores, ep_center, covs[train_set],
               ep_colors, 'Z-score of Euclidean distance to reference')
plt.show()

Online Artifact Detection with Potato

Detect artifacts/outliers on test set, with an animation to imitate an online acquisition, processing and artifact detection of EEG time-series. Initialized with an offline calibration, the online potato can be 2:

• static: it is never updated, damaging its efficiency over time;

• semi-dynamic: it is updated when EEG is not artifacted.

is_static = False       # static or semi-dynamic mode

# Prepare data for online detection
test_covs_max = 300     # nb of matrices to visualize in this example
test_covs_visu = 30     # nb of matrices to display simultaneously
test_time_start = -2    # start time to display signal
test_time_end = 5       # end time to display signal

time_start = train_covs * interval + test_time_start
time_end = train_covs * interval + test_time_end
time = np.linspace(time_start, time_end, int((time_end - time_start) * sfreq),
                   endpoint=False)
eeg_data = 3e5 * raw.get_data(picks=ch_names)
sig = eeg_data[:, int(time_start * sfreq):int(time_end * sfreq)]
covs_visu, rp_colors, ep_colors = np.empty([0, 2, 2]), [], []
alphas = np.linspace(0, 1, test_covs_visu)

fig = plt.figure(figsize=(12, 10), constrained_layout=False)
fig.suptitle('Online artifact detection by potatoes', fontsize=16)
gs = fig.add_gridspec(nrows=4, ncols=40, top=0.90, hspace=0.3, wspace=1.0)
ax_sig0 = fig.add_subplot(gs[0, :], xlabel='Time (s)', ylabel=ch_names[0])
pl_sig0 = plot_sig(ax_sig0, time, sig[0])
ax_sig1 = fig.add_subplot(gs[1, :], ylabel=ch_names[1])
pl_sig1 = plot_sig(ax_sig1, time, sig[1])
ax_sig1.set_xticks([])
ax_rp = fig.add_subplot(gs[2:4, 0:15], xlabel=xlabel, ylabel=ylabel,
                        title='2D projection of Riemannian potato')
cax_rp = fig.add_subplot(gs[2:4, 15])
p_rp = plot_potato_2D(ax_rp, cax_rp, X, Y, rp_mzscores, rp_center, covs_visu,
                      rp_colors, 'Z-score of Riemannian distance to reference')
ax_ep = fig.add_subplot(gs[2:4, 21:36], xlabel=xlabel, ylabel=ylabel,
                        title='2D projection of Euclidean potato')
cax_ep = fig.add_subplot(gs[2:4, 36])
p_ep = plot_potato_2D(ax_ep, cax_ep, X, Y, ep_zscores, ep_center, covs_visu,
                      ep_colors, 'Z-score of Euclidean distance to reference')

# Prepare animation for online detection
def online_detect(t):
    global time, sig, covs_visu

    # Online artifact detection
    rp_label = rpotato.predict(covs[np.newaxis, t])[0]
    ep_label = epotato.predict(covs[np.newaxis, t])[0]
    if not is_static:
        if rp_label == 1:
            rpotato.partial_fit(covs[np.newaxis, t], alpha=1 / t)
        if ep_label == 1:
            epotato.partial_fit(covs[np.newaxis, t], alpha=1 / t)

    # Update data
    time_start = t * interval + test_time_end
    time_end = (t + 1) * interval + test_time_end
    time_ = np.linspace(time_start, time_end, int(interval * sfreq),
                        endpoint=False)
    time = np.r_[time[int(interval * sfreq):], time_]
    sig = np.hstack((sig[:, int(interval*sfreq):],
                     eeg_data[:, int(time_start*sfreq):int(time_end*sfreq)]))
    covs_visu = np.vstack((covs_visu, covs[np.newaxis, t]))
    rp_colors.append('b' if rp_label == 1 else 'r')
    ep_colors.append('b' if ep_label == 1 else 'r')
    if len(covs_visu) > test_covs_visu:
        covs_visu = covs_visu[1:]
        rp_colors.pop(0)
        ep_colors.pop(0)
    rp_colors_ = _add_alpha(rp_colors, alphas)
    ep_colors_ = _add_alpha(ep_colors, alphas)

    # Update plot
    pl_sig0.set_data(time, sig[0])
    pl_sig0.axes.set_xlim(time[0], time[-1])
    pl_sig1.set_data(time, sig[1])
    pl_sig1.axes.set_xlim(time[0], time[-1])
    p_rp.set_offsets(np.c_[covs_visu[:, 0, 0], covs_visu[:, 1, 1]])
    p_rp.set_color(rp_colors_)
    p_ep.set_offsets(np.c_[covs_visu[:, 0, 0], covs_visu[:, 1, 1]])
    p_ep.set_color(ep_colors_)
    return pl_sig0, pl_sig1, p_rp, p_ep


interval_display = 1.0  # can be changed for a slower display

potato = FuncAnimation(fig, online_detect,
                       frames=range(train_covs, test_covs_max),
                       interval=interval_display, blit=False, repeat=False)

# Plot online detection

# Plot complete visu: a dynamic display is required
plt.show()

# Plot only 10s, for animated documentation
try:
    from IPython.display import HTML
except ImportError:
    raise ImportError("Install IPython to plot animation in documentation")

plt.rcParams["animation.embed_limit"] = 10
HTML(potato.to_jshtml(fps=5, default_mode='loop'))

Animation size has reached 10608001 bytes, exceeding the limit of 10485760.0. If you're sure you want a larger animation embedded, set the animation.embed_limit rc parameter to a larger value (in MB). This and further frames will be dropped.

Once Loop Reflect

References

1

The Riemannian Potato: an automatic and adaptive artifact detection method for online experiments using Riemannian geometry A. Barachant, A Andreev, and M. Congedo. TOBI Workshop lV, Jan 2013, Sion, Switzerland. pp.19-20

2(1,2)

The Riemannian Potato Field: A Tool for Online Signal Quality Index of EEG Q. Barthélemy, L. Mayaud, D. Ojeda, and M. Congedo. IEEE Transactions on Neural Systems and Rehabilitation Engineering, IEEE Institute of Electrical and Electronics Engineers, 2019, 27 (2), pp.244-255

Classification of motor imagery

Using Riemannian geometry for classifying motor imagery.

Motor imagery classification

Motor imagery classification

Ensemble learning on functional connectivity

Ensemble learning on functional connectivity

Frequency band selection on the manifold for motor imagery classification

Frequency band selection on the manifold for motor imagery classification

Motor imagery classification

Classify motor imagery data with Riemannian geometry 1.

# generic import
import numpy as np
import pandas as pd
import seaborn as sns
from matplotlib import pyplot as plt

# mne import
from mne import Epochs, pick_types, events_from_annotations
from mne.io import concatenate_raws
from mne.io.edf import read_raw_edf
from mne.datasets import eegbci
from mne.decoding import CSP

# pyriemann import
from pyriemann.classification import MDM, TSclassifier
from pyriemann.estimation import Covariances

# sklearn imports
from sklearn.model_selection import cross_val_score, KFold
from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression

Set parameters and read data

# avoid classification of evoked responses by using epochs that start 1s after
# cue onset.
tmin, tmax = 1., 2.
event_id = dict(hands=2, feet=3)
subject = 7
runs = [6, 10, 14]  # motor imagery: hands vs feet

raw_files = [
    read_raw_edf(f, preload=True) for f in eegbci.load_data(subject, runs)
]
raw = concatenate_raws(raw_files)

picks = pick_types(
    raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads')
# subsample elecs
picks = picks[::2]

# Apply band-pass filter
raw.filter(7., 35., method='iir', picks=picks)

events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3))

# Read epochs (train will be done only between 1 and 2s)
# Testing will be done with a running classifier
epochs = Epochs(
    raw,
    events,
    event_id,
    tmin,
    tmax,
    proj=True,
    picks=picks,
    baseline=None,
    preload=True,
    verbose=False)
labels = epochs.events[:, -1] - 2

# cross validation
cv = KFold(n_splits=10, shuffle=True, random_state=42)
# get epochs
epochs_data_train = 1e6 * epochs.get_data()

# compute covariance matrices
cov_data_train = Covariances().transform(epochs_data_train)

Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S007/S007R06.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S007/S007R10.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S007/S007R14.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Filtering a subset of channels. The highpass and lowpass values in the measurement info will not be updated.
Filtering raw data in 3 contiguous segments
Setting up band-pass filter from 7 - 35 Hz

IIR filter parameters
---------------------
Butterworth bandpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 16 (effective, after forward-backward)
- Cutoffs at 7.00, 35.00 Hz: -6.02, -6.02 dB

Used Annotations descriptions: ['T1', 'T2']

Classification with Minimum distance to mean

mdm = MDM(metric=dict(mean='riemann', distance='riemann'))

# Use scikit-learn Pipeline with cross_val_score function
scores = cross_val_score(mdm, cov_data_train, labels, cv=cv, n_jobs=1)

# Printing the results
class_balance = np.mean(labels == labels[0])
class_balance = max(class_balance, 1. - class_balance)
print("MDM Classification accuracy: %f / Chance level: %f" % (np.mean(scores),
                                                              class_balance))

MDM Classification accuracy: 0.850000 / Chance level: 0.511111

Classification with Tangent Space Logistic Regression

clf = TSclassifier()
# Use scikit-learn Pipeline with cross_val_score function
scores = cross_val_score(clf, cov_data_train, labels, cv=cv, n_jobs=1)

# Printing the results
class_balance = np.mean(labels == labels[0])
class_balance = max(class_balance, 1. - class_balance)
print("Tangent space Classification accuracy: %f / Chance level: %f" %
      (np.mean(scores), class_balance))

Tangent space Classification accuracy: 0.960000 / Chance level: 0.511111

Classification with CSP + logistic regression

# Assemble a classifier
lr = LogisticRegression()
csp = CSP(n_components=4, reg='ledoit_wolf', log=True)

clf = Pipeline([('CSP', csp), ('LogisticRegression', lr)])
scores = cross_val_score(clf, epochs_data_train, labels, cv=cv, n_jobs=1)

# Printing the results
class_balance = np.mean(labels == labels[0])
class_balance = max(class_balance, 1. - class_balance)
print("CSP + LDA Classification accuracy: %f / Chance level: %f" %
      (np.mean(scores), class_balance))

Computing rank from data with rank=None
    Using tolerance 33 (2.2e-16 eps * 32 dim * 4.7e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 29 (2.2e-16 eps * 32 dim * 4.1e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 33 (2.2e-16 eps * 32 dim * 4.6e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 28 (2.2e-16 eps * 32 dim * 4e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 34 (2.2e-16 eps * 32 dim * 4.7e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 27 (2.2e-16 eps * 32 dim * 3.8e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 33 (2.2e-16 eps * 32 dim * 4.7e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 29 (2.2e-16 eps * 32 dim * 4e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 31 (2.2e-16 eps * 32 dim * 4.4e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 29 (2.2e-16 eps * 32 dim * 4.1e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 30 (2.2e-16 eps * 32 dim * 4.2e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 29 (2.2e-16 eps * 32 dim * 4.1e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 31 (2.2e-16 eps * 32 dim * 4.4e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 28 (2.2e-16 eps * 32 dim * 4e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 34 (2.2e-16 eps * 32 dim * 4.7e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 28 (2.2e-16 eps * 32 dim * 3.9e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 32 (2.2e-16 eps * 32 dim * 4.5e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 29 (2.2e-16 eps * 32 dim * 4.1e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 32 (2.2e-16 eps * 32 dim * 4.5e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
Computing rank from data with rank=None
    Using tolerance 26 (2.2e-16 eps * 32 dim * 3.7e+15  max singular value)
    Estimated rank (mag): 32
    MAG: rank 32 computed from 32 data channels with 0 projectors
Reducing data rank from 32 -> 32
Estimating covariance using LEDOIT_WOLF
Done.
CSP + LDA Classification accuracy: 0.900000 / Chance level: 0.511111

Display MDM centroid

mdm = MDM()
mdm.fit(cov_data_train, labels)

fig, axes = plt.subplots(1, 2, figsize=[8, 4])
ch_names = [ch.replace('.', '') for ch in epochs.ch_names]

df = pd.DataFrame(data=mdm.covmeans_[0], index=ch_names, columns=ch_names)
g = sns.heatmap(
    df, ax=axes[0], square=True, cbar=False, xticklabels=2, yticklabels=2)
g.set_title('Mean covariance - hands')

df = pd.DataFrame(data=mdm.covmeans_[1], index=ch_names, columns=ch_names)
g = sns.heatmap(
    df, ax=axes[1], square=True, cbar=False, xticklabels=2, yticklabels=2)
plt.xticks(rotation='vertical')
plt.yticks(rotation='horizontal')
g.set_title('Mean covariance - feets')

# dirty fix
plt.sca(axes[0])
plt.xticks(rotation='vertical')
plt.yticks(rotation='horizontal')
plt.show()

References

1

Multiclass Brain-Computer Interface Classification by Riemannian Geometry A. Barachant, S. Bonnet, M. Congedo, and C. Jutten. IEEE Transactions on Biomedical Engineering, vol. 59, no. 4, p. 920-928, 2012.

Ensemble learning on functional connectivity

This example shows how to compute SPD matrices from functional connectivity estimators and how to combine classification with ensemble learning 1.

# Authors: Sylvain Chevallier <sylvain.chevallier@universite-paris-saclay.fr>,
#          Marie-Constance Corsi <marie.constance.corsi@gmail.com>
#
# License: BSD (3-clause)

import matplotlib.pyplot as plt

from mne import Epochs, pick_types, events_from_annotations
from mne.io import concatenate_raws
from mne.io.edf import read_raw_edf
from mne.datasets import eegbci

import numpy as np
import pandas as pd
import seaborn as sns

from pyriemann.classification import FgMDM
from pyriemann.estimation import Covariances, Coherences
from pyriemann.spatialfilters import CSP
from pyriemann.tangentspace import TangentSpace

from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV, StratifiedKFold
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC

from helpers.coherence_helpers import (
    NearestSPD,
    get_results,
)

Define connectivity transformer

This estimator computes the functional connectivity from input signal using pyriemann.estimation.Coherences

class Connectivities(TransformerMixin, BaseEstimator):
    """Getting connectivity features from epoch"""

    def __init__(self, method="ordinary", fmin=8, fmax=35, fs=None):
        self.method = method
        self.fmin = fmin
        self.fmax = fmax
        self.fs = fs

    def fit(self, X, y=None):
        self._coh = Coherences(
            coh=self.method,
            fmin=self.fmin,
            fmax=self.fmax,
            fs=self.fs,
        )
        return self

    def transform(self, X):
        X_coh = self._coh.fit_transform(X)
        X_con = np.mean(X_coh, axis=-1, keepdims=False)
        return X_con

Load EEG data

# avoid classification of evoked responses by using epochs that start 1s after
# cue onset.
tmin, tmax = 1.0, 2.0
event_id = dict(hands=2, feet=3)
subject = 7
runs = [4, 8]  # motor imagery: left vs right hand

raw_files = [
    read_raw_edf(f, preload=True) for f in eegbci.load_data(subject, runs)
]
raw = concatenate_raws(raw_files)

picks = pick_types(
    raw.info, meg=False, eeg=True, stim=False, eog=False, exclude="bads"
)
# subsample elecs
picks = picks[::2]

# Apply band-pass filter
raw.filter(7.0, 35.0, method="iir", picks=picks)

events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3))

# Read epochs (train will be done only between 1 and 2s)
epochs = Epochs(
    raw,
    events,
    event_id,
    tmin,
    tmax,
    proj=True,
    picks=picks,
    baseline=None,
    preload=True,
    verbose=False,
)
labels = epochs.events[:, -1] - 2
fs = epochs.info["sfreq"]
X = 1e6 * epochs.get_data()

Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S007/S007R04.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S007/S007R08.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Filtering a subset of channels. The highpass and lowpass values in the measurement info will not be updated.
Filtering raw data in 2 contiguous segments
Setting up band-pass filter from 7 - 35 Hz

IIR filter parameters
---------------------
Butterworth bandpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 16 (effective, after forward-backward)
- Cutoffs at 7.00, 35.00 Hz: -6.02, -6.02 dB

Used Annotations descriptions: ['T1', 'T2']

Defining pipelines

Compare CSP+SVM, FgMDM on covariance, tangent space logistic regression with covariance, lag coherence, and instantaneous coherence, along with ensemble method

ppl_baseline, ppl_fc, ppl_ens = {}, {}, {}

Baseline algorithms are CSP with optimal SVM and FgMDM based on covariances

param_svm = {"kernel": ("linear", "rbf"), "C": [0.1, 1, 10]}
step_csp = [
    ("cov", Covariances(estimator="lwf")),
    ("csp", CSP(nfilter=6)),
    ("optsvm", GridSearchCV(SVC(), param_svm, cv=3)),
]
ppl_baseline["CSP+optSVM"] = Pipeline(steps=step_csp)

step_mdm = [
    ("cov", Covariances(estimator="lwf")),
    ("fgmdm", FgMDM(metric="riemann", tsupdate=False)),
]
ppl_baseline["FgMDM"] = Pipeline(steps=step_mdm)

Functional connectivity pipelines use logistic regression in tangent space. They will be estimated from covariance, lagged coherence and instantaneous coherence.

spectral_met = ["cov", "lagged", "instantaneous"]
fmin, fmax = 8, 35
param_lr = {
    "penalty": "elasticnet",
    "l1_ratio": 0.15,
    "intercept_scaling": 1000.0,
    "solver": "saga",
}
param_ft = {"fmin": fmin, "fmax": fmax, "fs": fs}
step_fc = [
    ("spd", NearestSPD()),
    ("tg", TangentSpace(metric="riemann")),
    ("LogistReg", LogisticRegression(**param_lr)),
]
for sm in spectral_met:
    pname = sm + "+elasticnet"
    if sm == "cov":
        ppl_fc[pname] = Pipeline(
            steps=[("cov", Covariances(estimator="lwf"))] + step_fc
        )
    else:
        ft = Connectivities(**param_ft, method=sm)
        ppl_fc[pname] = Pipeline(steps=[("ft", ft)] + step_fc)

The ensemble classifier stacks a logistic regression on top of the three functional connectivity pipelines to make a global prediction

fc_estim = [(n, ppl_fc[n]) for n in ppl_fc]
cvkf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

lr = LogisticRegression(**param_lr)
ppl_ens["ensemble"] = StackingClassifier(
    estimators=fc_estim,
    cv=cvkf,
    n_jobs=1,
    final_estimator=lr,
    stack_method="predict_proba",
)

Evaluation

dataset_res = list()
all_ppl = {**ppl_baseline, **ppl_ens}

# Compute results
results = get_results(X, labels, all_ppl)
results = pd.DataFrame(results)

/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/linear_model/_sag.py:354: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge
  ConvergenceWarning,

Plot

list_fc_ens = ["ensemble", "CSP+optSVM", "FgMDM"] + \
    [sm + "+elasticnet" for sm in spectral_met]

g = sns.catplot(
    data=results,
    x="pipeline",
    y="score",
    kind="bar",
    order=list_fc_ens,
    height=7,
    aspect=2,
)
plt.show()

References

1

Functional connectivity ensemble method to enhance BCI performance (FUCONE) Corsi, M.-C., Chevallier, S., De Vico Fallani, F. & Yger, F. IEEE TBME, 2022

Frequency band selection on the manifold for motor imagery classification

Find optimal frequency band using class distinctiveness measure on the manifold and compare classification performance for motor imagery data to the baseline with no frequency band selection 1.

# Authors: Maria Sayu Yamamoto <maria-sayu.yamamoto@universite-paris-saclay.fr>
#
# License: BSD (3-clause)


import numpy as np
from time import time
from matplotlib import pyplot as plt

from mne import Epochs, pick_types, events_from_annotations
from mne.io import concatenate_raws
from mne.io.edf import read_raw_edf
from mne.datasets import eegbci

from sklearn.model_selection import cross_val_score, ShuffleSplit

from pyriemann.classification import MDM
from pyriemann.estimation import Covariances
from helpers.frequencybandselection_helpers import freq_selection_class_dis

Set basic parameters and read data

tmin, tmax = 0.5, 2.5
event_id = dict(T1=2, T2=3)
subject = 1
runs = [4, 8, 12]  # motor imagery: left hand vs right hand

raw_files = [
    read_raw_edf(f, preload=True) for f in eegbci.load_data(subject, runs)
]
raw = concatenate_raws(raw_files)
picks = pick_types(
    raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads')
# subsample elecs
picks = picks[::2]

# cross validation
cv = ShuffleSplit(n_splits=1, test_size=0.2, random_state=42)

Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S001/S001R04.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S001/S001R08.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S001/S001R12.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...

Baseline pipeline without frequency band selection

Apply band-pass filter using a wide frequency band, 5-35 Hz. Train and evaluate classifier.

t0 = time()
raw_filter = raw.copy().filter(5., 35., method='iir', picks=picks,
                               verbose=False)

events, _ = events_from_annotations(raw_filter, event_id,
                                    verbose=False)

# Read epochs (train will be done only between 0.5 and 2.5 s)
epochs = Epochs(
    raw_filter,
    events,
    event_id,
    tmin,
    tmax,
    proj=True,
    picks=picks,
    baseline=None,
    preload=True,
    verbose=False)
labels = epochs.events[:, -1] - 2

# Get epochs
epochs_data_baseline = epochs.get_data(units="uV")

# Compute covariance matrices
cov_data_baseline = Covariances().transform(epochs_data_baseline)

# Set classifier
model = MDM(metric=dict(mean='riemann', distance='riemann'))

# Classification with minimum distance to mean
acc_baseline = cross_val_score(model, cov_data_baseline, labels,
                               cv=cv, n_jobs=1)
t1 = time() - t0

Pipeline with a frequency band selection based on the class distinctiveness

Step1: Select frequency band maximizing class distinctiveness on training set.

Define parameters for frequency band selection

t2 = time()
freq_band = [5., 35.]
sub_band_width = 4.
sub_band_step = 2.
alpha = 0.4

# Select frequency band using training set
best_freq, all_class_dis = \
    freq_selection_class_dis(raw, freq_band, sub_band_width,
                             sub_band_step, alpha,
                             tmin, tmax,
                             picks, event_id,
                             cv,
                             return_class_dis=True, verbose=False)

print(f'Selected frequency band : {best_freq[0][0]} - {best_freq[0][1]} Hz')

Selected frequency band : 9.0 - 15.0 Hz

Step2: Train classifier using selected frequency band and evaluate performance using test set

# Apply band-pass filter using the best frequency band
best_raw_filter = raw.copy().filter(best_freq[0][0], best_freq[0][1],
                                    method='iir', picks=picks,
                                    verbose=False)

events, _ = events_from_annotations(best_raw_filter, event_id,
                                    verbose=False)

# Read epochs (train will be done only between 0.5 and 2.5s)
epochs = Epochs(
    best_raw_filter,
    events,
    event_id,
    tmin,
    tmax,
    proj=True,
    picks=picks,
    baseline=None,
    preload=True,
    verbose=False)

# Get epochs
epochs_data_train = epochs.get_data(units="uV")

# Estimate covariance matrices
cov_data = Covariances().transform(epochs_data_train)

# Classification with minimum distance to mean
acc = cross_val_score(model, cov_data, labels, cv=cv, n_jobs=1)
t3 = time() - t2

Compare pipelines: accuracies and training times

print("Classification accuracy without frequency band selection: "
      + f"{acc_baseline[0]:.02f}")
print("Total computational time without frequency band selection: "
      + f"{t1:.5f} s")
print("Classification accuracy with frequency band selection: "
      + f"{acc[0]:.02f}")
print("Total computational time with frequency band selection: "
      + f"{t3:.5f} s")

Classification accuracy without frequency band selection: 0.56
Total computational time without frequency band selection: 0.32673 s
Classification accuracy with frequency band selection: 0.67
Total computational time with frequency band selection: 11.92862 s

Plot selected frequency bands

Plot the class distinctiveness values for each sub_band, along with the highlight of the finally selected frequency band.

subband_fmin = list(np.arange(freq_band[0],
                              freq_band[1] - sub_band_width + 1.,
                              sub_band_step))
subband_fmax = list(np.arange(freq_band[0] + sub_band_width,
                              freq_band[1] + 1., sub_band_step))
n_subband = len(subband_fmin)

x = list(range(0, n_subband, 1))
fig = plt.figure(figsize=(10, 5))

freq_start = subband_fmin.index(best_freq[0][0])
freq_end = subband_fmax.index(best_freq[0][1])

plt.subplot(1, 1, 1)
plt.grid()
plt.plot(x, all_class_dis[0], marker='o')
plt.xticks(list(range(0, 14, 1)),
           [[int(i), int(j)] for i, j in zip(subband_fmin, subband_fmax)])

plt.axvspan(freq_start, freq_end, color="orange", alpha=0.3,
            label='Selected frequency band')
plt.ylabel('Class distinctiveness')
plt.xlabel('Filter bank [Hz]')
plt.title('Class distinctiveness value of each subband')
plt.legend(loc='upper right')

fig.tight_layout()
plt.show()

print(f'Optimal frequency band for this subject is '
      f'{best_freq[0][0]} - {best_freq[0][1]} Hz')

Optimal frequency band for this subject is 9.0 - 15.0 Hz

References

1

Class-distinctiveness-based frequency band selection on the Riemannian manifold for oscillatory activity-based BCIs: preliminary results M. S. Yamamoto, F. Lotte, F. Yger, and S. Chevallier. 44th Annual International Conference of the IEEE Engineering in Medicine & Biology Society (EMBC2022), 2022.

Covariance estimation

Examples for covariance matrix estimation.

Robust covariance estimation

Robust covariance estimation

Compare covariance and kernel estimators with different time windows

Compare covariance and kernel estimators with different time windows

Robust covariance estimation

Comparison of robustness of different covariance estimators on a corrupted low-dimensional dataset. See also 1.

# Author: Quentin Barthélemy
#
# License: BSD (3-clause)

import numpy as np
from matplotlib import pyplot as plt
from matplotlib.patches import Ellipse
import matplotlib.transforms as transforms

from pyriemann.estimation import Covariances

def plot_cov_ellipse(ax, cov, n_std=2.5, **kwargs):
    """Inspired by
    https://matplotlib.org/stable/gallery/statistics/confidence_ellipse.html
    """
    pearson = cov[0, 1] / np.sqrt(cov[0, 0] * cov[1, 1])
    ell_radius_x = np.sqrt(1 + pearson)
    ell_radius_y = np.sqrt(1 - pearson)
    ellipse = Ellipse((0, 0), width=ell_radius_x * 2, height=ell_radius_y * 2,
                      facecolor='none', **kwargs)
    scale_x = np.sqrt(cov[0, 0]) * n_std
    scale_y = np.sqrt(cov[1, 1]) * n_std
    transf = transforms.Affine2D().rotate_deg(45).scale(scale_x, scale_y)
    ellipse.set_transform(transf + ax.transData)
    return ax.add_patch(ellipse)


def plot_cov_estimators(ax, X, estimators):
    plot_cov_ellipse(ax, C_ref, edgecolor="C0", label='Reference')
    for i, est in enumerate(estimators):
        C = Covariances(estimator=est).transform(X[np.newaxis, ...])[0]
        plot_cov_ellipse(ax, C, edgecolor=f"C{i+2}", label=est)
    ax.legend(loc='upper left')
    return ax

Generate a Gaussian dataset

Input samples are generated from a centered 2D Gaussian distribution considered as the reference.

rs = np.random.RandomState(2023)

n_channels, n_inliers = 2, 50
C_ref = np.array([[1, 0.6], [0.6, 1.5]])
X = C_ref @ rs.randn(n_channels, n_inliers)

Estimate covariance matrices on dataset

Compare reference covariance matrix to different estimators:

• sample covariance matrix (scm),

• Ledoit-Wolf shrunk covariance matrix (lwf),

• oracle approximating shrunk covariance matrix (oas),

• minimum covariance determinant matrix (mcd),

• robust Huber’s M-estimator based covariance matrix (hub).

estimators = ["scm", "lwf", "oas", "mcd", "hub"]

fig, ax = plt.subplots(figsize=(7, 7))
ax.set_title("Covariance estimations on dataset")
ax.scatter(X[0], X[1], c='C0', edgecolors="k", label='Inputs')
ax = plot_cov_estimators(ax, X, estimators)
xlim, ylim = ax.get_xlim(), ax.get_ylim()
min_, max_ = min(xlim[0], ylim[0]), max(xlim[1], ylim[1])
ax.set_xlim(min_, max_)
ax.set_ylim(min_, max_)
plt.show()

Add outliers to dataset

Outliers are added to the dataset.

n_outliers = 7
mu, scale = np.array([15, 1]), 5
Xout = mu[:, np.newaxis] + scale * rs.randn(n_channels, n_outliers)
X = np.concatenate((X, Xout), axis=1)

Estimate covariance matrices on corrupted dataset

Compare robustness of the different estimators.

fig, ax = plt.subplots(figsize=(14, 7))
ax.set_title("Covariance estimations on corrupted dataset")
ax.scatter(X[0, :n_inliers], X[1, :n_inliers], c='C0', edgecolors="k",
           label='Inliers')
ax.scatter(X[0, n_inliers:], X[1, n_inliers:], c='C1', edgecolors="k",
           label='Outliers')
ax = plot_cov_estimators(ax, X, estimators)
plt.show()

References

1

https://scikit-learn.org/stable/auto_examples/covariance/plot_mahalanobis_distances.html # noqa

Compare covariance and kernel estimators with different time windows

Comparison of covariance estimators for different EEG signal lengths and their impact on classification 1. Kernel estimators are also compared 2.

# Authors: Sylvain Chevallier and Quentin Barthélemy
#
# License: BSD (3-clause)

import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
import seaborn as sns

from mne import Epochs, pick_types, events_from_annotations
from mne.io import concatenate_raws
from mne.io.edf import read_raw_edf
from mne.datasets import eegbci
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.pipeline import make_pipeline

from pyriemann.estimation import Covariances, Kernels
from pyriemann.utils.distance import distance
from pyriemann.classification import MDM

Estimating covariance on synthetic data

Generate synthetic data, sampled from a distribution considered as the groundtruth.

rs = np.random.RandomState(42)
n_matrices, n_channels, n_times = 10, 5, 1000
var = 2.0 + 0.1 * rs.randn(n_matrices, n_channels)
A = 2 * rs.rand(n_channels, n_channels) - 1
A /= np.linalg.norm(A, axis=1)[:, np.newaxis]
true_covs = np.empty(shape=(n_matrices, n_channels, n_channels))
X = np.empty(shape=(n_matrices, n_channels, n_times))
for i in range(n_matrices):
    true_covs[i] = A @ np.diag(var[i]) @ A.T
    X[i] = rs.multivariate_normal(
        np.array([0.0] * n_channels), true_covs[i], size=n_times
    ).T

Covariances() class offers several estimators:

• sample covariance matrix (SCM),

• Ledoit-Wolf (LWF),

• Schaefer-Strimmer (SCH),

• oracle approximating shrunk (OAS) covariance,

• minimum covariance determinant (MCD),

• and others.

We will compare the distance of LWF, OAS and SCH estimators with the groundtruth, while increasing epoch length.

estimators = ["lwf", "oas", "sch"]
w_len = np.linspace(10, n_times, 20, dtype=int)
dfd = list()
for est in estimators:
    for wl in w_len:
        est_covs = Covariances(estimator=est).transform(X[:, :, :wl])
        dists = distance(est_covs, true_covs, metric="riemann")
        dfd.extend([dict(estimator=est, wlen=wl, dist=d) for d in dists])
dfd = pd.DataFrame(dfd)

fig, ax = plt.subplots(figsize=(6, 4))
ax.set(xscale="log")
sns.lineplot(data=dfd, x="wlen", y="dist", hue="estimator", ax=ax)
ax.set_title("Distance to groundtruth covariance matrix")
ax.set_xlabel("Number of time samples")
ax.set_ylabel(r"$\delta(\Sigma, \hat{\Sigma})$")
plt.tight_layout()
plt.show()

Choice of estimator for motor imagery data

Loading data from PhysioNet MI dataset, for subject 1.

event_id = dict(hands=2, feet=3)
subject = 1
runs = [6, 10, 14]  # motor imagery: hands vs feet
raw_files = [
    read_raw_edf(f, preload=True, stim_channel="auto")
    for f in eegbci.load_data(subject, runs)
]
raw = concatenate_raws(raw_files)
picks = pick_types(raw.info, eeg=True, exclude="bads")

# subsample elecs
picks = picks[::2]
# Apply band-pass filter
raw.filter(7.0, 35.0, method="iir", picks=picks, skip_by_annotation="edge")
events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3))
event_ids = dict(hands=2, feet=3)

Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S001/S001R06.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S001/S001R10.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Extracting EDF parameters from /home/docs/mne_data/MNE-eegbci-data/files/eegmmidb/1.0.0/S001/S001R14.edf...
EDF file detected
Setting channel info structure...
Creating raw.info structure...
Reading 0 ... 19999  =      0.000 ...   124.994 secs...
Filtering a subset of channels. The highpass and lowpass values in the measurement info will not be updated.
Filtering raw data in 3 contiguous segments
Setting up band-pass filter from 7 - 35 Hz

IIR filter parameters
---------------------
Butterworth bandpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 16 (effective, after forward-backward)
- Cutoffs at 7.00, 35.00 Hz: -6.02, -6.02 dB

Used Annotations descriptions: ['T1', 'T2']

Influence of shrinkage to estimate matrices

Sample covariance matrix (SCM) estimation could lead to ill-conditionned matrices depending on the quality and quantity of EEG data available. Matrix condition number is the ratio between the highest and lowest eigenvalues: high values indicates ill-conditionned matrices that are not suitable for classification. A common approach to mitigate this issue is to regularize covariance matrices by shrinkage, like in Ledoit-Wolf, Schaefer-Strimmer or oracle estimators.

In addition to covariance matrices, kernel matrices are computed for three kernel functions:

• radial basis function (RBF),

• polynomial,

• Laplacian.

estimators = [
    "cov-lwf", "cov-oas", "cov-sch", "cov-scm",
    "ker-rbf", "ker-polynomial", "ker-laplacian",
]
tmin = -0.2
w_len = np.linspace(0.2, 2, 10)
n_matrices = 45
dfc = list()

for wl in w_len:
    X = Epochs(
        raw,
        events,
        event_ids,
        tmin,
        tmin + wl,
        picks=picks,
        preload=True,
        verbose=False,
    ).get_data()
    for est in estimators:
        est_class, est_param = est.split('-')
        if est_class == "ker":
            covs = Kernels(metric=est_param).transform(X)
        else:
            covs = Covariances(estimator=est_param).transform(X)
        evals, _ = np.linalg.eigh(covs)
        dfc.extend([dict(estimator=est, wlen=wl, cond=e[-1] / e[0])
                    for e in evals])
dfc = pd.DataFrame(dfc)

fig, ax = plt.subplots(figsize=(6, 4))
ax.set(yscale="log")
sns.lineplot(data=dfc, x="wlen", y="cond", hue="estimator", ax=ax)
ax.set_title("Condition number of estimated matrices")
ax.set_xlabel("Epoch length (s)")
ax.set_ylabel(r"$\lambda_{\max}$/$\lambda_{\min}$")
plt.tight_layout()
plt.show()

/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/pandas/core/arraylike.py:364: RuntimeWarning: invalid value encountered in log10
  result = getattr(ufunc, method)(*inputs, **kwargs)

Picking a good estimator for classification

The choice of estimator have an impact on classification, especially when the matrices are estimated on short time windows.

tmin = 0.0
w_len = np.linspace(0.2, 2.0, 5)
n_matrices, n_splits = 45, 5
dfa = list()
sc = "balanced_accuracy"

cv = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=123)
for wl in w_len:
    epochs = Epochs(
        raw,
        events,
        event_ids,
        tmin,
        tmin + wl,
        proj=True,
        picks=picks,
        preload=True,
        baseline=None,
        verbose=False,
    )
    X = epochs.get_data()
    y = np.array([0 if ev == 2 else 1 for ev in epochs.events[:, -1]])
    for est in estimators:
        est_class, est_param = est.split('-')
        if est_class == "ker":
            clf = make_pipeline(Kernels(metric=est_param), MDM())
        else:
            clf = make_pipeline(Covariances(estimator=est_param), MDM())
        try:
            score = cross_val_score(clf, X, y, cv=cv, scoring=sc)
            dfa += [dict(estimator=est, wlen=wl, accuracy=sc) for sc in score]
        except ValueError:
            print(f"{est}: {wl} is not sufficent to estimate a SPD matrix")
            dfa += [dict(estimator=est, wlen=wl, accuracy=np.nan)] * n_splits
dfa = pd.DataFrame(dfa)

/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/model_selection/_validation.py:372: FitFailedWarning:
5 fits failed out of a total of 5.
The score on these train-test partitions for these parameters will be set to nan.
If these failures are not expected, you can try to debug them by setting error_score='raise'.

Below are more details about the failures:
--------------------------------------------------------------------------------
5 fits failed with the following error:
Traceback (most recent call last):
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/model_selection/_validation.py", line 680, in _fit_and_score
    estimator.fit(X_train, y_train, **fit_params)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/pipeline.py", line 394, in fit
    self._final_estimator.fit(Xt, y, **fit_params_last_step)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/classification.py", line 124, in fit
    for ll in self.classes_]
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/classification.py", line 124, in <listcomp>
    for ll in self.classes_]
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py", line 591, in mean_covariance
    C = mean_methods[metric](covmats, sample_weight=sample_weight, *args)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py", line 458, in mean_riemann
    C = C12 @ expm(nu * J) @ C12
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py", line 95, in expm
    return _matrix_operator(C, np.exp)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py", line 15, in _matrix_operator
    "Matrices must be positive definite. Add "
ValueError: Matrices must be positive definite. Add regularization to avoid this error.

  warnings.warn(some_fits_failed_message, FitFailedWarning)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/model_selection/_validation.py:372: FitFailedWarning:
5 fits failed out of a total of 5.
The score on these train-test partitions for these parameters will be set to nan.
If these failures are not expected, you can try to debug them by setting error_score='raise'.

Below are more details about the failures:
--------------------------------------------------------------------------------
5 fits failed with the following error:
Traceback (most recent call last):
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/model_selection/_validation.py", line 680, in _fit_and_score
    estimator.fit(X_train, y_train, **fit_params)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/pipeline.py", line 394, in fit
    self._final_estimator.fit(Xt, y, **fit_params_last_step)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/classification.py", line 124, in fit
    for ll in self.classes_]
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/classification.py", line 124, in <listcomp>
    for ll in self.classes_]
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py", line 591, in mean_covariance
    C = mean_methods[metric](covmats, sample_weight=sample_weight, *args)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py", line 458, in mean_riemann
    C = C12 @ expm(nu * J) @ C12
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py", line 95, in expm
    return _matrix_operator(C, np.exp)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py", line 15, in _matrix_operator
    "Matrices must be positive definite. Add "
ValueError: Matrices must be positive definite. Add regularization to avoid this error.

  warnings.warn(some_fits_failed_message, FitFailedWarning)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py:18: RuntimeWarning: invalid value encountered in log
  eigvals = operator(eigvals)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/model_selection/_validation.py:372: FitFailedWarning:
5 fits failed out of a total of 5.
The score on these train-test partitions for these parameters will be set to nan.
If these failures are not expected, you can try to debug them by setting error_score='raise'.

Below are more details about the failures:
--------------------------------------------------------------------------------
5 fits failed with the following error:
Traceback (most recent call last):
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/model_selection/_validation.py", line 680, in _fit_and_score
    estimator.fit(X_train, y_train, **fit_params)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/sklearn/pipeline.py", line 394, in fit
    self._final_estimator.fit(Xt, y, **fit_params_last_step)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/classification.py", line 124, in fit
    for ll in self.classes_]
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/classification.py", line 124, in <listcomp>
    for ll in self.classes_]
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py", line 591, in mean_covariance
    C = mean_methods[metric](covmats, sample_weight=sample_weight, *args)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py", line 458, in mean_riemann
    C = C12 @ expm(nu * J) @ C12
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py", line 95, in expm
    return _matrix_operator(C, np.exp)
  File "/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/base.py", line 15, in _matrix_operator
    "Matrices must be positive definite. Add "
ValueError: Matrices must be positive definite. Add regularization to avoid this error.

  warnings.warn(some_fits_failed_message, FitFailedWarning)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:470: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')

fig, ax = plt.subplots(figsize=(6, 4))
sns.lineplot(
    data=dfa,
    x="wlen",
    y="accuracy",
    hue="estimator",
    style="estimator",
    ax=ax,
    ci=None,
    markers=True,
    dashes=False,
)
ax.set_title("Accuracy for different estimators and epoch lengths")
ax.set_xlabel("Epoch length (s)")
ax.set_ylabel("Classification accuracy")
plt.tight_layout()
plt.show()

/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/examples/signal/plot_covariance_estimation.py:223: FutureWarning:

The `ci` parameter is deprecated. Use `errorbar=None` for the same effect.

  dashes=False,

References

1

Riemannian classification for SSVEP based BCI: offline versus online implementations S. Chevallier, E. Kalunga, Q. Barthélemy, F. Yger. Brain–Computer Interfaces Handbook: Technological and Theoretical Advances, 2018.

2

Beyond Covariance: Feature Representation with Nonlinear Kernel Matrices # noqa L. Wang, J. Zhang, L. Zhou, C. Tang, W Li. ICCV, 2015.

Simulated data

Examples using datasets sampled from known probability distributions.

Sample from the Riemannian Gaussian distribution in the SPD manifold

Sample from the Riemannian Gaussian distribution in the SPD manifold

Classification accuracy vs class distinctiveness vs class separability

Classification accuracy vs class distinctiveness vs class separability

Mean and median comparison

Mean and median comparison

Estimate mean of SPD matrices with NaN values

Estimate mean of SPD matrices with NaN values

Classifier comparison

Classifier comparison

Sample from the Riemannian Gaussian distribution in the SPD manifold

Spectral embedding of samples from the Riemannian Gaussian distribution with different centerings and dispersions.

# Authors: Pedro Rodrigues <pedro.rodrigues@melix.org>
#
# License: BSD (3-clause)

import numpy as np
import matplotlib.pyplot as plt

from pyriemann.embedding import SpectralEmbedding
from pyriemann.datasets import sample_gaussian_spd, generate_random_spd_matrix


print(__doc__)

Set parameters for sampling from the Riemannian Gaussian distribution

n_matrices = 100  # how many SPD matrices to generate
n_dim = 2  # number of dimensions of the SPD matrices
sigma = 1.0  # dispersion of the Gaussian distribution
epsilon = 4.0  # parameter for controlling the distance between centers
random_state = 42  # ensure reproducibility

# Generate the samples on three different conditions
mean = generate_random_spd_matrix(n_dim)  # random reference point

samples_1 = sample_gaussian_spd(n_matrices=n_matrices,
                                mean=mean,
                                sigma=sigma,
                                random_state=random_state)
samples_2 = sample_gaussian_spd(n_matrices=n_matrices,
                                mean=mean,
                                sigma=sigma/2,
                                random_state=random_state)
samples_3 = sample_gaussian_spd(n_matrices=n_matrices,
                                mean=epsilon*mean,
                                sigma=sigma,
                                random_state=random_state)

# Stack all of the samples into one data array for the embedding
samples = np.concatenate([samples_1, samples_2, samples_3])
labels = np.array(n_matrices*[1] + n_matrices*[2] + n_matrices*[3])

Apply the spectral embedding over the SPD matrices

lapl = SpectralEmbedding(metric='riemann', n_components=2)
embd = lapl.fit_transform(X=samples)

Plot the results

fig, ax = plt.subplots(figsize=(8, 6))

colors = {1: 'C0', 2: 'C1', 3: 'C2'}
for i in range(len(samples)):
    ax.scatter(embd[i, 0], embd[i, 1], c=colors[labels[i]], s=50)
ax.scatter([], [], c='C0', s=50, label=r'$\varepsilon = 1.00, \sigma = 1.00$')
ax.scatter([], [], c='C1', s=50, label=r'$\varepsilon = 1.00, \sigma = 0.50$')
ax.scatter([], [], c='C2', s=50, label=r'$\varepsilon = 4.00, \sigma = 1.00$')
ax.set_xticks([-1, -0.5, 0, 0.5, 1.0])
ax.set_xticklabels([-1, -0.5, 0, 0.5, 1.0], fontsize=12)
ax.set_yticks([-1, -0.5, 0, 0.5, 1.0])
ax.set_yticklabels([-1, -0.5, 0, 0.5, 1.0], fontsize=12)
ax.set_title(r'Spectral embedding of data points (fixed $n_{dim} = 4$)',
             fontsize=14)
ax.set_xlabel(r'$\phi_1$', fontsize=14)
ax.set_ylabel(r'$\phi_2$', fontsize=14)
ax.legend()

plt.show()

Classification accuracy vs class distinctiveness vs class separability

Generate several datasets containing data points from two-classes. Each class is generated with a Riemannian Gaussian distribution centered at the class mean and with the same dispersion sigma. The distance between the class means is parametrized by Delta, which we make vary between zero and 5*sigma. We illustrate how the accuracy of the MDM classifier and the value of the class distinctiveness 1 vary when Delta increases.

# Authors: Pedro Rodrigues <pedro.rodrigues@melix.org>
#          Maria Sayu Yamamoto <maria-sayu.yamamoto@universite-paris-saclay.fr>
#
# License: BSD (3-clause)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import cross_val_score, StratifiedKFold

from pyriemann.classification import MDM
from pyriemann.datasets import make_gaussian_blobs
from pyriemann.classification import class_distinctiveness

Set general parameters for the illustrations

n_matrices = 100  # how many matrices to sample on each class
n_dim = 4  # dimensionality of the data points
sigma = 1.0  # dispersion of the Gaussian distributions
random_state = 42  # ensure reproducibility

Loop over different levels of separability between the classes

scores_array = []
class_dis_array = []
deltas_array = np.linspace(0, 3*sigma, 10)

for delta in deltas_array:
    # generate data points for a classification problem
    X, y = make_gaussian_blobs(n_matrices=n_matrices,
                               n_dim=n_dim,
                               class_sep=delta,
                               class_disp=sigma,
                               random_state=random_state,
                               n_jobs=4)

    # measure class distinctiveness of training data for each split
    skf = StratifiedKFold(n_splits=5)
    all_class_dis = []
    for train_ind, _ in skf.split(X, y):
        class_dis = class_distinctiveness(X[train_ind], y[train_ind],
                                          exponent=1, metric='riemann',
                                          return_num_denom=False)
        all_class_dis.append(class_dis)

    # average class distinctiveness across splits
    mean_class_dis = np.mean(all_class_dis)
    class_dis_array.append(mean_class_dis)

    # Now let's train a MDM classifier and measure its performance
    clf = MDM()

    # get the classification score for this setup
    scores_array.append(
        cross_val_score(clf, X, y, cv=skf, scoring='roc_auc').mean())

scores_array = np.array(scores_array)
class_dis_array = np.array(class_dis_array)

Plot the results

fig, (ax1, ax2) = plt.subplots(sharex=True, nrows=2)

ax1.plot(deltas_array, scores_array, lw=3.0, label=r'ROC AUC score')
ax2.plot(deltas_array, class_dis_array, lw=3.0, color='g',
         label='Class Distinctiveness')

ax2.set_xlabel(r'$\Delta/\sigma$', fontsize=14)
ax1.set_ylabel(r'ROC AUC score', fontsize=12)
ax2.set_ylabel(r'class distinctiveness', fontsize=12)
ax1.set_title('Classification score and class distinctiveness value\n'
              r'vs. class separability ($n_{dim} = 4$)',
              fontsize=12)

ax1.grid(True)
ax2.grid(True)
fig.tight_layout()
plt.show()

References

1

Class-distinctiveness-based frequency band selection on the Riemannian manifold for oscillatory activity-based BCIs: preliminary results M. S. Yamamoto, F. Lotte, F. Yger, and S. Chevallier. 44th Annual International Conference of the IEEE Engineering in Medicine & Biology Society (EMBC2022), 2022.

Mean and median comparison

A comparison between Euclidean and Riemannian means 1, and Euclidean and Riemannian geometric medians 2, on low-dimensional synthetic datasets.

# Authors: Quentin Barthélemy
#
# License: BSD (3-clause)

import numpy as np
import matplotlib.pyplot as plt

from sklearn.datasets import make_blobs
from pyriemann.datasets import make_outliers
from pyriemann.utils import mean_euclid, mean_riemann
from pyriemann.utils import median_euclid, median_riemann
from pyriemann.clustering import Potato

rs = np.random.RandomState(17)

Data in vector space

Dataset of 2D vectors, reproducing Fig 1 of reference 2.

Notice how the few outliers at the top right of the picture have forced the mean away from the points, whereas the geometric median remains centrally located.

X, y = make_blobs(
    n_samples=[7, 9, 6],
    n_features=2,
    centers=np.array([[-1, -10], [-10, -4], [10, 5]]),
    cluster_std=[2, 2, 2],
    random_state=rs
)
is_inlier = (y <= 1)

C_mean = mean_euclid(X[..., np.newaxis])
C_mmed = np.median(X, axis=0)
C_gmed = median_euclid(X[..., np.newaxis])

fig, ax = plt.subplots(figsize=(7, 7))
fig.suptitle("Mean and median for 2D vectors", fontsize=16)
ax.scatter(X[is_inlier, 0], X[is_inlier, 1], c='C0', edgecolors="k",
           label='Inliers')
ax.scatter(X[~is_inlier, 0], X[~is_inlier, 1], c='C1', edgecolors="k",
           label='Outliers')
ax.scatter(C_mean[0], C_mean[1], c='r', marker="x", label='Euclidean mean')
ax.scatter(C_mmed[0], C_mmed[1], c='r', marker=">",
           label='Marginal Euclidean median')
ax.scatter(C_gmed[0], C_gmed[1], c='r', marker="s",
           label='Geometric Euclidean median')
ax.legend(loc='upper left')
plt.show()

Data in manifold of SPD matrices

Dataset of 2x2 SPD matrices.

A dynamic display is required if you want to rotate or zoom the 3D figure. This 3D plot can be tricky to interpret. 2x2 SPD matrices can be viewed as spatial coordinates contained in a hyper-cone 3. In Euclidean geometry, null matrix is the center of space. In Riemannian geometry, identity matrix is the center of the unbounded and non-linear manifold 3: due to log(.)^2 in the affine-invariant distance, an eigenvalue of 10 contributes to the distance from the identity as much as an eigenvalue 0.1.

n_channels, n_inliers, n_outliers = 2, 16, 6

Cin = 0.2 * np.eye(n_channels)
Xin = make_outliers(n_inliers, Cin, 0.5, outlier_coeff=1, random_state=rs)
Xout = make_outliers(
    n_outliers, 4 * np.eye(n_channels), 0.5, outlier_coeff=1, random_state=rs)
X = np.concatenate([Xin, Xout])

C_emean = mean_euclid(X)
C_rmean = mean_riemann(X)
C_emed = median_euclid(X)
C_rmed = median_riemann(X)

fig2 = plt.figure(figsize=(7, 7))
fig2.suptitle("Means and medians for 2x2 SPD matrices", fontsize=16)
ax2 = plt.subplot(111, projection='3d')
ax2.scatter(1, 0, 1, c="k", marker="+", s=50, label='Identity')
ax2.scatter(Xin[:, 0, 0], Xin[:, 0, 1], Xin[:, 1, 1], c="C0", edgecolors="k",
            label='Inliers')
ax2.scatter(Xout[:, 0, 0], Xout[:, 0, 1], Xout[:, 1, 1], c="C1",
            edgecolors="k", label='Outliers')
ax2.scatter(C_emean[0, 0], C_emean[0, 1], C_emean[1, 1], c="r", marker="x",
            label='Euclidean mean')
ax2.scatter(C_rmean[0, 0], C_rmean[0, 1], C_rmean[1, 1], c="m", marker="x",
            label='Riemannian mean')
ax2.scatter(C_emed[0, 0], C_emed[0, 1], C_emed[1, 1], c="r", marker="s",
            label='Euclidean median')
ax2.scatter(C_rmed[0, 0], C_rmed[0, 1], C_rmed[1, 1], c="m", marker="s",
            label='Riemannian median')
ax2.legend(loc='center left', bbox_to_anchor=(0.7, 0.6))
plt.show()

Photo finish

Specific zoom on means and medians.

Surprise guest: Riemannian potato is fitted with an offline iterative outlier removal, providing a robust mean 4.

C_rp = Potato(metric='riemann', threshold=1.5).fit(X).covmean_

fig3 = plt.figure(figsize=(7, 7))
fig3.suptitle("Means and medians for 2x2 SPD matrices\nZoom", fontsize=16)
ax3 = plt.subplot(111, projection='3d')
ax3.scatter(1, 0, 1, c="k", marker="+", s=50, label='Identity')
ax3.scatter(Cin[0, 0], Cin[0, 1], Cin[1, 1], c="C0", edgecolors="k", s=50,
            label='Center of inliers')
ax3.scatter(C_emean[0, 0], C_emean[0, 1], C_emean[1, 1], c="r", marker="x",
            label='Euclidean mean')
ax3.scatter(C_rmean[0, 0], C_rmean[0, 1], C_rmean[1, 1], c="m", marker="x",
            label='Riemannian mean')
ax3.scatter(C_emed[0, 0], C_emed[0, 1], C_emed[1, 1], c="r", marker="s",
            label='Euclidean median')
ax3.scatter(C_rmed[0, 0], C_rmed[0, 1], C_rmed[1, 1], c="m", marker="s",
            label='Riemannian median')
ax3.scatter(C_rp[0, 0], C_rp[0, 1], C_rp[1, 1], c="chartreuse", marker="*",
            s=40, label='Center of\nRiemannian potato')
ax3.legend(loc='center left', bbox_to_anchor=(0.7, 0.5))
plt.show()

References

1

Review of Riemannian distances and divergences, applied to SSVEP-based BCI S. Chevallier, E. K. Kalunga, Q. Barthélemy, E. Monacelli. Neuroinformatics, Springer, 2021, 19 (1), pp.93-106

2(1,2)

The geometric median on Riemannian manifolds with application to robust atlas estimation PT. Fletcher, S. Venkatasubramanian S and S. Joshi. NeuroImage, 2009, 45(1), S143-S152

3(1,2)

EEG source analysis M. Congedo. HdR, 2013, Chap IX

4

The Riemannian Potato Field: A Tool for Online Signal Quality Index of EEG Q. Barthélemy, L. Mayaud, D. Ojeda, and M. Congedo. IEEE Transactions on Neural Systems and Rehabilitation Engineering, 2019, 27 (2), pp.244-255

Estimate mean of SPD matrices with NaN values

Estimate the mean of SPD matrices corrupted by NaN values 1.

# Author: Quentin Barthélemy, Sylvain Chevallier and Florian Yger
#
# License: BSD (3-clause)

import numpy as np
from matplotlib import pyplot as plt
import pandas as pd
import seaborn as sns

from pyriemann.datasets import make_covariances
from pyriemann.utils.mean import mean_riemann, nanmean_riemann
from pyriemann.utils.distance import distance_riemann

def corrupt(covmats, n_corrup_channels_max, rs):
    n_matrices, n_channels, _ = covmats.shape
    all_n_corrup_channels, all_corrup_channels = np.zeros(n_matrices), []
    for i_matrix in range(n_matrices):
        n_corrupt_channels = rs.randint(n_corrup_channels_max + 1, size=1)
        corrup_channels = rs.choice(
            np.arange(0, n_channels), size=n_corrupt_channels, replace=False)
        for i_channel in corrup_channels:
            covmats[i_matrix, i_channel] = np.nan
            covmats[i_matrix, :, i_channel] = np.nan
            all_corrup_channels.append(i_channel)
        all_n_corrup_channels[i_matrix] = n_corrupt_channels
    return covmats, all_n_corrup_channels, all_corrup_channels

Generate data

rs = np.random.RandomState(42)
n_matrices, n_channels = 100, 10
covmats = make_covariances(
    n_matrices, n_channels, rs, evals_mean=100., evals_std=20.)

# Compute the reference, the Riemannian mean on all SPD matrices
C_ref = mean_riemann(covmats)

# Corrupt data randomly
n_corrup_channels_max = n_channels // 2
print("Maximum number of corrupted channels: {} over {}".format(
    n_corrup_channels_max, n_channels))

covmats, all_n_corrup_channels, all_corrup_channels = corrupt(
    covmats, n_corrup_channels_max, rs)

fig, ax = plt.subplots(nrows=1, ncols=1)
ax.set(title='Histogram of the number of corrupted channels',
       xlabel='Channel count', ylabel='Occurrences')
plt.hist(all_n_corrup_channels, bins=np.arange(n_corrup_channels_max + 2) - .5)
plt.show()

Maximum number of corrupted channels: 5 over 10

fig, ax = plt.subplots(nrows=1, ncols=1)
ax.set(title='Histogram of the indices of corrupted channels',
       xlabel='Channel index', ylabel='Occurrences')
plt.hist(all_corrup_channels, bins=np.arange(n_channels + 1) - .5)
plt.show()

Estimate means of SPD matrices

Riemannian mean could only be computed on full-rank matrices. A common strategy is called matrix deletion, that is removing all matrices with corrupted channels before computing mean. This results in discarding useful information as uncorrupted channels are removed from the computation of the mean. Nan-mean uses as much information as possible to estimate the mean 1.

# Euclidean NaN-mean
C_naneucl = np.nanmean(covmats, axis=0)

# Riemannian NaN-mean
C_nanriem = nanmean_riemann(covmats)

# Riemannian mean, after matrix deletion: average only uncorrupted matrices
isnan = np.isnan(np.sum(covmats, axis=(1, 2)))
covmats_ = np.delete(covmats, np.where(isnan), axis=0)
perc = len(covmats_) / n_matrices * 100
print("Percentage of uncorrupted matrices: {:.2f} %".format(perc))
C_mdriem = mean_riemann(covmats_)

/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:700: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')
Percentage of uncorrupted matrices: 13.00 %

Compare means

Compare distances between the different means and the reference.

d_naneucl = distance_riemann(C_ref, C_naneucl)
print(f"Euclidean NaN-mean, distance to ref = {d_naneucl:.3f}")

d_nanriem = distance_riemann(C_ref, C_nanriem)
print(f"Riemannian NaN-mean, distance to ref = {d_nanriem:.3f}")

d_mdriem = distance_riemann(C_ref, C_mdriem)
print(f"Riemannian mean after deletion, distance to ref = {d_mdriem:.3f}")

# Riemannian NaN-mean gives the best result, and Riemannian mean after matrix
# deletion is worst than Euclidean NaN-mean.

Euclidean NaN-mean, distance to ref = 0.081
Riemannian NaN-mean, distance to ref = 0.051
Riemannian mean after deletion, distance to ref = 0.127

Evaluate influence of corrupted channels

Repeat the previous experiment, varying the maximum number of corrupted channels 1.

covmats_orig = make_covariances(
    n_matrices, n_channels, rs, evals_mean=100., evals_std=20.)
C_ref = mean_riemann(covmats_orig)

df = []
for n_corrup_channels_max in range(0, n_channels // 2 + 1):
    covmats = np.copy(covmats_orig)
    covmats, _, _ = corrupt(covmats, n_corrup_channels_max, rs)

    C_naneucl = np.nanmean(covmats, axis=0)
    C_nanriem = nanmean_riemann(covmats)
    isnan = np.isnan(np.sum(covmats, axis=(1, 2)))
    covmats_ = np.delete(covmats, np.where(isnan), axis=0)
    C_mdriem = mean_riemann(covmats_)

    res_naneucl = {'n_corrupt': n_corrup_channels_max,
                   'dist': distance_riemann(C_ref, C_naneucl),
                   'Means': 'Euclidean NaN-mean'}
    res_nanriem = {'n_corrupt': n_corrup_channels_max,
                   'dist': distance_riemann(C_ref, C_nanriem),
                   'Means': 'Riemannian NaN-mean'}
    res_mdriem = {'n_corrupt': n_corrup_channels_max,
                  'dist': distance_riemann(C_ref, C_mdriem),
                  'Means': 'Riemannian mean after deletion'}
    df += [res_naneucl, res_nanriem, res_mdriem]
df = pd.DataFrame(df)

g = sns.catplot(data=df, x="n_corrupt", y="dist", hue="Means", kind="point",
                legend_out=False)
g.set(title="Influence of corrupted channels")
g.set_axis_labels("Maximum number of corrupted channels",
                  "Distance to reference")
plt.tight_layout()
plt.show()

/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/utils/mean.py:700: UserWarning: Convergence not reached
  warnings.warn('Convergence not reached')

References

1(1,2,3)

Geodesically-convex optimization for averaging partially observed covariance matrices F. Yger, S. Chevallier, Q. Barthélemy, and S. Sra. Asian Conference on Machine Learning (ACML), Nov 2020, Bangkok, Thailand. pp.417 - 432.

Classifier comparison

A comparison of several classifiers on low-dimensional synthetic datasets, adapted to SPD matrices from 1. The point of this example is to illustrate the nature of decision boundaries of different classifiers, used with different metrics 2. This should be taken with a grain of salt, as the intuition conveyed by these examples does not necessarily carry over to real datasets.

The 3D plots show training matrices in solid colors and testing matrices semi-transparent. The lower right shows the classification accuracy on the test set.

# Authors: Quentin Barthélemy
#
# License: BSD (3-clause)

from functools import partial
from time import time

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn.model_selection import train_test_split

from pyriemann.datasets import make_covariances, make_gaussian_blobs
from pyriemann.classification import (
    MDM,
    KNearestNeighbor,
    SVC,
    MeanField,
)

@partial(np.vectorize, excluded=['clf'])
def get_proba(cov_00, cov_01, cov_11, clf):
    cov = np.array([[cov_00, cov_01], [cov_01, cov_11]])
    with np.testing.suppress_warnings() as sup:
        sup.filter(RuntimeWarning)
        return clf.predict_proba(cov[np.newaxis, ...])[0, 1]


def plot_classifiers(metric):
    figure = plt.figure(figsize=(12, 10))
    figure.suptitle(f"Compare classifiers with metric='{metric}'", fontsize=16)
    i = 1

    # iterate over datasets
    for ds_cnt, (X, y) in enumerate(datasets):
        # split dataset into training and test part
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.4, random_state=42
        )

        x_min, x_max = X[:, 0, 0].min(), X[:, 0, 0].max()
        y_min, y_max = X[:, 0, 1].min(), X[:, 0, 1].max()
        z_min, z_max = X[:, 1, 1].min(), X[:, 1, 1].max()

        # just plot the dataset first
        ax = plt.subplot(n_datasets, n_classifs + 1, i, projection='3d')
        if ds_cnt == 0:
            ax.set_title("Input data")
        # Plot the training points
        ax.scatter(
            X_train[:, 0, 0],
            X_train[:, 0, 1],
            X_train[:, 1, 1],
            c=y_train,
            cmap=cm_bright,
            edgecolors="k"
        )
        # Plot the testing points
        ax.scatter(
            X_test[:, 0, 0],
            X_test[:, 0, 1],
            X_test[:, 1, 1],
            c=y_test,
            cmap=cm_bright,
            alpha=0.6,
            edgecolors="k"
        )
        ax.set_xlim(x_min, x_max)
        ax.set_ylim(y_min, y_max)
        ax.set_zlim(z_min, z_max)
        ax.set_xticklabels(())
        ax.set_yticklabels(())
        ax.set_zticklabels(())
        i += 1

        rx = np.arange(x_min, x_max, (x_max - x_min) / 50)
        ry = np.arange(y_min, y_max, (y_max - y_min) / 50)
        rz = np.arange(z_min, z_max, (z_max - z_min) / 50)

        print(f"Dataset n°{ds_cnt+1}")

        # iterate over classifiers
        for name, clf in zip(names, classifiers):
            ax = plt.subplot(n_datasets, n_classifs + 1, i, projection='3d')

            clf.set_params(**{'metric': metric})
            t0 = time()
            clf.fit(X_train, y_train)
            t1 = time() - t0

            t0 = time()
            score = clf.score(X_test, y_test)
            t2 = time() - t0

            print(
                f" {name}:\n  training time={t1:.5f}\n  test time    ={t2:.5f}"
            )

            # Plot the decision boundaries for horizontal 2D planes going
            # through the mean value of the third coordinates
            xx, yy = np.meshgrid(rx, ry)
            zz = get_proba(xx, yy, X[:, 1, 1].mean()*np.ones_like(xx), clf=clf)
            zz = np.ma.masked_where(~np.isfinite(zz), zz)
            ax.contourf(xx, yy, zz, zdir='z', offset=z_min, cmap=cm, alpha=0.5)

            xx, zz = np.meshgrid(rx, rz)
            yy = get_proba(xx, X[:, 0, 1].mean()*np.ones_like(xx), zz, clf=clf)
            yy = np.ma.masked_where(~np.isfinite(yy), yy)
            ax.contourf(xx, yy, zz, zdir='y', offset=y_max, cmap=cm, alpha=0.5)

            yy, zz = np.meshgrid(ry, rz)
            xx = get_proba(X[:, 0, 0].mean()*np.ones_like(yy), yy, zz, clf=clf)
            xx = np.ma.masked_where(~np.isfinite(xx), xx)
            ax.contourf(xx, yy, zz, zdir='x', offset=x_min, cmap=cm, alpha=0.5)

            # Plot the training points
            ax.scatter(
                X_train[:, 0, 0],
                X_train[:, 0, 1],
                X_train[:, 1, 1],
                c=y_train,
                cmap=cm_bright,
                edgecolors="k"
            )
            # Plot the testing points
            ax.scatter(
                X_test[:, 0, 0],
                X_test[:, 0, 1],
                X_test[:, 1, 1],
                c=y_test,
                cmap=cm_bright,
                edgecolors="k",
                alpha=0.6
            )

            if ds_cnt == 0:
                ax.set_title(name)
            ax.text(
                1.3 * x_max,
                y_min,
                z_min,
                ("%.2f" % score).lstrip("0"),
                size=15,
                horizontalalignment="right",
                verticalalignment="bottom"
            )
            ax.set_xlim(x_min, x_max)
            ax.set_ylim(y_min, y_max)
            ax.set_zlim(z_min, z_max)
            ax.set_xticks(())
            ax.set_yticks(())
            ax.set_zticks(())

            i += 1

    plt.show()

Classifiers and Datasets

names = [
    "MDM",
    "k-NN",
    "SVC",
    "MeanField",
]
classifiers = [
    MDM(),
    KNearestNeighbor(n_neighbors=3),
    SVC(probability=True),
    MeanField(power_list=[-1, 0, 1]),
]
n_classifs = len(classifiers)

rs = np.random.RandomState(2022)
n_matrices, n_channels = 50, 2
y = np.concatenate([np.zeros(n_matrices), np.ones(n_matrices)])

datasets = [
    (
        np.concatenate([
            make_covariances(
                n_matrices, n_channels, rs, evals_mean=10, evals_std=1
            ),
            make_covariances(
                n_matrices, n_channels, rs, evals_mean=15, evals_std=1
            )
        ]),
        y
    ),
    (
        np.concatenate([
            make_covariances(
                n_matrices, n_channels, rs, evals_mean=10, evals_std=2
            ),
            make_covariances(
                n_matrices, n_channels, rs, evals_mean=12, evals_std=2
            )
        ]),
        y
    ),
    make_gaussian_blobs(
        2*n_matrices, n_channels, random_state=rs, class_sep=1., class_disp=.2,
        n_jobs=4
    ),
    make_gaussian_blobs(
        2*n_matrices, n_channels, random_state=rs, class_sep=.5, class_disp=.5,
        n_jobs=4
    )
]
n_datasets = len(datasets)

cm = plt.cm.RdBu
cm_bright = ListedColormap(["#FF0000", "#0000FF"])

Classifiers with Riemannian metric

plot_classifiers("riemann")

Dataset n°1
 MDM:
  training time=0.00231
  test time    =0.00700
 k-NN:
  training time=0.00007
  test time    =0.15219
 SVC:
  training time=0.00379
  test time    =0.00156
 MeanField:
  training time=0.01839
  test time    =0.02721
Dataset n°2
 MDM:
  training time=0.00232
  test time    =0.00700
 k-NN:
  training time=0.00007
  test time    =0.15237
 SVC:
  training time=0.00444
  test time    =0.00157
 MeanField:
  training time=0.01870
  test time    =0.02717
Dataset n°3
 MDM:
  training time=0.00540
  test time    =0.01329
 k-NN:
  training time=0.00006
  test time    =0.45100
 SVC:
  training time=0.00721
  test time    =0.00182
 MeanField:
  training time=0.02700
  test time    =0.05377
Dataset n°4
 MDM:
  training time=0.00700
  test time    =0.01320
 k-NN:
  training time=0.00005
  test time    =0.45257
 SVC:
  training time=0.00837
  test time    =0.00199
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/numpy/lib/function_base.py:2246: RuntimeWarning: invalid value encountered in func (vectorized)
  outputs = ufunc(*inputs)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/numpy/lib/function_base.py:2246: RuntimeWarning: invalid value encountered in func (vectorized)
  outputs = ufunc(*inputs)
 MeanField:
  training time=0.02855
  test time    =0.05409

Classifiers with Log-Euclidean metric

plot_classifiers("logeuclid")

Dataset n°1
 MDM:
  training time=0.00094
  test time    =0.01077
 k-NN:
  training time=0.00007
  test time    =0.20882
 SVC:
  training time=0.00228
  test time    =0.00134
 MeanField:
  training time=0.01910
  test time    =0.03975
Dataset n°2
 MDM:
  training time=0.00089
  test time    =0.01072
 k-NN:
  training time=0.00006
  test time    =0.20895
 SVC:
  training time=0.00244
  test time    =0.00144
 MeanField:
  training time=0.01873
  test time    =0.03919
Dataset n°3
 MDM:
  training time=0.00107
  test time    =0.02071
 k-NN:
  training time=0.00006
  test time    =0.68054
 SVC:
  training time=0.00266
  test time    =0.00150
 MeanField:
  training time=0.02699
  test time    =0.07650
Dataset n°4
 MDM:
  training time=0.00116
  test time    =0.02090
 k-NN:
  training time=0.00005
  test time    =0.68378
 SVC:
  training time=0.00416
  test time    =0.00167
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/numpy/lib/function_base.py:2246: RuntimeWarning: invalid value encountered in func (vectorized)
  outputs = ufunc(*inputs)
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/envs/stable/lib/python3.7/site-packages/numpy/lib/function_base.py:2246: RuntimeWarning: invalid value encountered in func (vectorized)
  outputs = ufunc(*inputs)
 MeanField:
  training time=0.02925
  test time    =0.07944

Classifiers with Euclidean metric

plot_classifiers("euclid")

Dataset n°1
 MDM:
  training time=0.00042
  test time    =0.00208
 k-NN:
  training time=0.00007
  test time    =0.04554
 SVC:
  training time=0.00149
  test time    =0.00084
 MeanField:
  training time=0.01871
  test time    =0.01119
Dataset n°2
 MDM:
  training time=0.00037
  test time    =0.00203
 k-NN:
  training time=0.00007
  test time    =0.04541
 SVC:
  training time=0.00264
  test time    =0.00084
 MeanField:
  training time=0.01850
  test time    =0.01099
Dataset n°3
 MDM:
  training time=0.00040
  test time    =0.00367
 k-NN:
  training time=0.00005
  test time    =0.14052
 SVC:
  training time=0.00187
  test time    =0.00087
 MeanField:
  training time=0.02740
  test time    =0.02164
Dataset n°4
 MDM:
  training time=0.00037
  test time    =0.00369
 k-NN:
  training time=0.00005
  test time    =0.14013
 SVC:
  training time=0.00328
  test time    =0.00093
 MeanField:
  training time=0.02820
  test time    =0.02118

References

1

https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html # noqa

2

Review of Riemannian distances and divergences, applied to SSVEP-based BCI S. Chevallier, E. K. Kalunga, Q. Barthélemy, E. Monacelli. Neuroinformatics, Springer, 2021, 19 (1), pp.93-106

Permutation test

Permutation test with pyRiemann.

One Way manova time

One Way manova time

One Way manova with Frequenty

One Way manova with Frequenty

One Way manova

One Way manova

Manova for ERP data

Manova for ERP data

One Way manova time

One way manova to compare Left vs Right in time.

import numpy as np
import seaborn as sns

from time import time
from pylab import plt

from mne import Epochs, pick_types, events_from_annotations
from mne.io import concatenate_raws
from mne.io.edf import read_raw_edf
from mne.datasets import eegbci

from pyriemann.stats import PermutationDistance
from pyriemann.estimation import Covariances

sns.set_style('whitegrid')

Set parameters and read data

# avoid classification of evoked responses by using epochs that start 1s after
# cue onset.
tmin, tmax = -2., 6.
event_id = dict(hands=2, feet=3)
subject = 1
runs = [6, 10, 14]  # motor imagery: hands vs feet

raw_files = [
    read_raw_edf(f, preload=True, verbose=False)
    for f in eegbci.load_data(subject, runs)
]
raw = concatenate_raws(raw_files)

events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3))
picks = pick_types(
    raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads')

raw.filter(7., 35., method='iir', picks=picks)

epochs = Epochs(
    raw,
    events,
    event_id,
    tmin,
    tmax,
    proj=True,
    picks=picks,
    baseline=None,
    preload=True,
    verbose=False)
labels = epochs.events[:, -1] - 2

# get epochs
epochs_data = epochs.get_data()

Used Annotations descriptions: ['T1', 'T2']
Filtering raw data in 3 contiguous segments
Setting up band-pass filter from 7 - 35 Hz

IIR filter parameters
---------------------
Butterworth bandpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 16 (effective, after forward-backward)
- Cutoffs at 7.00, 35.00 Hz: -6.02, -6.02 dB

Pairwise distance based permutation test

covest = Covariances()

Fs = 160
window = 2 * Fs
Nwindow = 20
Ns = epochs_data.shape[2]
step = int((Ns - window) / Nwindow)
time_bins = range(0, Ns - window, step)

pv = []
Fv = []
# For each frequency bin, estimate the stats
t_init = time()
for t in time_bins:
    covmats = covest.fit_transform(epochs_data[:, ::1, t:(t + window)])
    p_test = PermutationDistance(1000, metric='riemann', mode='pairwise')
    p, F = p_test.test(covmats, labels, verbose=False)
    pv.append(p)
    Fv.append(F[0])
duration = time() - t_init
# plot result
fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
sig = 0.05
times = np.array(time_bins) / float(Fs) + tmin

axes.plot(times, Fv, lw=2, c='k')
plt.xlabel('Time (sec)')
plt.ylabel('Score')

a = np.where(np.diff(np.array(pv) < sig))[0]
a = a.reshape(int(len(a) / 2), 2)
st = (times[1] - times[0]) / 2.0
for p in a:
    axes.axvspan(times[p[0]] - st, times[p[1]] + st, facecolor='g', alpha=0.5)
axes.legend(['Score', 'p<%.2f' % sig])
axes.set_title('Pairwise distance - %.1f sec.' % duration)

sns.despine()
plt.tight_layout()
plt.show()

One Way manova with Frequenty

One way manova to compare Left vs Right for each frequency.

import numpy as np
import seaborn as sns

from time import time
from pylab import plt
from mne import Epochs, pick_types, events_from_annotations
from mne.io import concatenate_raws
from mne.io.edf import read_raw_edf
from mne.datasets import eegbci

from pyriemann.stats import PermutationDistance
from pyriemann.estimation import CospCovariances

sns.set_style('whitegrid')

Set parameters and read data

# avoid classification of evoked responses by using epochs that start 1s after
# cue onset.
tmin, tmax = 1., 3.
event_id = dict(hands=2, feet=3)
subject = 1
runs = [6, 10, 14]  # motor imagery: hands vs feet

raw_files = [
    read_raw_edf(f, preload=True, verbose=False)
    for f in eegbci.load_data(subject, runs)
]
raw = concatenate_raws(raw_files)

events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3))
picks = pick_types(
    raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads')

# Read epochs (train will be done only between 1 and 2s)
# Testing will be done with a running classifier
epochs = Epochs(
    raw,
    events,
    event_id,
    tmin,
    tmax,
    proj=True,
    picks=picks,
    baseline=None,
    preload=True,
    verbose=False)
labels = epochs.events[:, -1] - 2

# get epochs
epochs_data = epochs.get_data()

# compute cospectral covariance matrices
fmin = 2.0
fmax = 40.0
cosp = CospCovariances(
    window=128, overlap=0.98, fmin=fmin, fmax=fmax, fs=160.0)
covmats = cosp.fit_transform(epochs_data[:, ::4, :])

fr = np.fft.fftfreq(128)[0:64] * 160
fr = fr[(fr >= fmin) & (fr <= fmax)]

Used Annotations descriptions: ['T1', 'T2']

Pairwise distance based permutation test

pv = []
Fv = []
# For each frequency bin, estimate the stats
t_init = time()
for i in range(covmats.shape[3]):
    p_test = PermutationDistance(1000, metric='riemann', mode='pairwise')
    p, F = p_test.test(covmats[:, :, :, i], labels, verbose=False)
    pv.append(p)
    Fv.append(F[0])
duration = time() - t_init

# plot result
fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
sig = 0.05
axes.plot(fr, Fv, lw=2, c='k')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Score')

a = np.where(np.diff(np.array(pv) < sig))[0]
a = a.reshape(int(len(a) / 2), 2)
st = (fr[1] - fr[0]) / 2.0
for p in a:
    axes.axvspan(fr[p[0]] - st, fr[p[1]] + st, facecolor='g', alpha=0.5)
axes.legend(['Score', 'p<%.2f' % sig])
axes.set_title('Pairwise distance - %.1f sec.' % duration)

sns.despine()
plt.tight_layout()
plt.show()

One Way manova

One way manova to compare Left vs Right.

import seaborn as sns

from time import time
from matplotlib import pyplot as plt

from mne import Epochs, pick_types, events_from_annotations
from mne.io import concatenate_raws
from mne.io.edf import read_raw_edf
from mne.datasets import eegbci

from pyriemann.stats import PermutationDistance, PermutationModel
from pyriemann.estimation import Covariances
from pyriemann.spatialfilters import CSP

from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression

sns.set_style('whitegrid')

Set parameters and read data

# avoid classification of evoked responses by using epochs that start 1s after
# cue onset.
tmin, tmax = 1., 3.
event_id = dict(hands=2, feet=3)
subject = 1
runs = [6, 10, 14]  # motor imagery: hands vs feet

raw_files = [
    read_raw_edf(f, preload=True, verbose=False)
    for f in eegbci.load_data(subject, runs)
]
raw = concatenate_raws(raw_files)

# Apply band-pass filter
raw.filter(7., 35., method='iir')

events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3))

picks = pick_types(
    raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads')
picks = picks[::4]

# Read epochs (train will be done only between 1 and 2s)
# Testing will be done with a running classifier
epochs = Epochs(
    raw,
    events,
    event_id,
    tmin,
    tmax,
    proj=True,
    picks=picks,
    baseline=None,
    preload=True,
    verbose=False)
labels = epochs.events[:, -1] - 2

# get epochs
epochs_data = epochs.get_data()

# compute covariance matrices
covmats = Covariances().fit_transform(epochs_data)

n_perms = 500

Filtering raw data in 3 contiguous segments
Setting up band-pass filter from 7 - 35 Hz

IIR filter parameters
---------------------
Butterworth bandpass zero-phase (two-pass forward and reverse) non-causal filter:
- Filter order 16 (effective, after forward-backward)
- Cutoffs at 7.00, 35.00 Hz: -6.02, -6.02 dB

Used Annotations descriptions: ['T1', 'T2']

Pairwise distance based permutation test

t_init = time()
p_test = PermutationDistance(n_perms, metric='riemann', mode='pairwise')
p, F = p_test.test(covmats, labels)
duration = time() - t_init

fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
p_test.plot(nbins=10, axes=axes)
plt.title('Pairwise distance - %.2f sec.' % duration)
print('p-value: %.3f' % p)
sns.despine()
plt.tight_layout()
plt.show()

Performing permutations : [0.2%]
Performing permutations : [0.4%]
Performing permutations : [0.6%]
Performing permutations : [0.8%]
Performing permutations : [1.0%]
Performing permutations : [1.2%]
Performing permutations : [1.4%]
Performing permutations : [1.6%]
Performing permutations : [1.8%]
Performing permutations : [2.0%]
Performing permutations : [2.2%]
Performing permutations : [2.4%]
Performing permutations : [2.6%]
Performing permutations : [2.8%]
Performing permutations : [3.0%]
Performing permutations : [3.2%]
Performing permutations : [3.4%]
Performing permutations : [3.6%]
Performing permutations : [3.8%]
Performing permutations : [4.0%]
Performing permutations : [4.2%]
Performing permutations : [4.4%]
Performing permutations : [4.6%]
Performing permutations : [4.8%]
Performing permutations : [5.0%]
Performing permutations : [5.2%]
Performing permutations : [5.4%]
Performing permutations : [5.6%]
Performing permutations : [5.8%]
Performing permutations : [6.0%]
Performing permutations : [6.2%]
Performing permutations : [6.4%]
Performing permutations : [6.6%]
Performing permutations : [6.8%]
Performing permutations : [7.0%]
Performing permutations : [7.2%]
Performing permutations : [7.4%]
Performing permutations : [7.6%]
Performing permutations : [7.8%]
Performing permutations : [8.0%]
Performing permutations : [8.2%]
Performing permutations : [8.4%]
Performing permutations : [8.6%]
Performing permutations : [8.8%]
Performing permutations : [9.0%]
Performing permutations : [9.2%]
Performing permutations : [9.4%]
Performing permutations : [9.6%]
Performing permutations : [9.8%]
Performing permutations : [10.0%]
Performing permutations : [10.2%]
Performing permutations : [10.4%]
Performing permutations : [10.6%]
Performing permutations : [10.8%]
Performing permutations : [11.0%]
Performing permutations : [11.2%]
Performing permutations : [11.4%]
Performing permutations : [11.6%]
Performing permutations : [11.8%]
Performing permutations : [12.0%]
Performing permutations : [12.2%]
Performing permutations : [12.4%]
Performing permutations : [12.6%]
Performing permutations : [12.8%]
Performing permutations : [13.0%]
Performing permutations : [13.2%]
Performing permutations : [13.4%]
Performing permutations : [13.6%]
Performing permutations : [13.8%]
Performing permutations : [14.0%]
Performing permutations : [14.2%]
Performing permutations : [14.4%]
Performing permutations : [14.6%]
Performing permutations : [14.8%]
Performing permutations : [15.0%]
Performing permutations : [15.2%]
Performing permutations : [15.4%]
Performing permutations : [15.6%]
Performing permutations : [15.8%]
Performing permutations : [16.0%]
Performing permutations : [16.2%]
Performing permutations : [16.4%]
Performing permutations : [16.6%]
Performing permutations : [16.8%]
Performing permutations : [17.0%]
Performing permutations : [17.2%]
Performing permutations : [17.4%]
Performing permutations : [17.6%]
Performing permutations : [17.8%]
Performing permutations : [18.0%]
Performing permutations : [18.2%]
Performing permutations : [18.4%]
Performing permutations : [18.6%]
Performing permutations : [18.8%]
Performing permutations : [19.0%]
Performing permutations : [19.2%]
Performing permutations : [19.4%]
Performing permutations : [19.6%]
Performing permutations : [19.8%]
Performing permutations : [20.0%]
Performing permutations : [20.2%]
Performing permutations : [20.4%]
Performing permutations : [20.6%]
Performing permutations : [20.8%]
Performing permutations : [21.0%]
Performing permutations : [21.2%]
Performing permutations : [21.4%]
Performing permutations : [21.6%]
Performing permutations : [21.8%]
Performing permutations : [22.0%]
Performing permutations : [22.2%]
Performing permutations : [22.4%]
Performing permutations : [22.6%]
Performing permutations : [22.8%]
Performing permutations : [23.0%]
Performing permutations : [23.2%]
Performing permutations : [23.4%]
Performing permutations : [23.6%]
Performing permutations : [23.8%]
Performing permutations : [24.0%]
Performing permutations : [24.2%]
Performing permutations : [24.4%]
Performing permutations : [24.6%]
Performing permutations : [24.8%]
Performing permutations : [25.0%]
Performing permutations : [25.2%]
Performing permutations : [25.4%]
Performing permutations : [25.6%]
Performing permutations : [25.8%]
Performing permutations : [26.0%]
Performing permutations : [26.2%]
Performing permutations : [26.4%]
Performing permutations : [26.6%]
Performing permutations : [26.8%]
Performing permutations : [27.0%]
Performing permutations : [27.2%]
Performing permutations : [27.4%]
Performing permutations : [27.6%]
Performing permutations : [27.8%]
Performing permutations : [28.0%]
Performing permutations : [28.2%]
Performing permutations : [28.4%]
Performing permutations : [28.6%]
Performing permutations : [28.8%]
Performing permutations : [29.0%]
Performing permutations : [29.2%]
Performing permutations : [29.4%]
Performing permutations : [29.6%]
Performing permutations : [29.8%]
Performing permutations : [30.0%]
Performing permutations : [30.2%]
Performing permutations : [30.4%]
Performing permutations : [30.6%]
Performing permutations : [30.8%]
Performing permutations : [31.0%]
Performing permutations : [31.2%]
Performing permutations : [31.4%]
Performing permutations : [31.6%]
Performing permutations : [31.8%]
Performing permutations : [32.0%]
Performing permutations : [32.2%]
Performing permutations : [32.4%]
Performing permutations : [32.6%]
Performing permutations : [32.8%]
Performing permutations : [33.0%]
Performing permutations : [33.2%]
Performing permutations : [33.4%]
Performing permutations : [33.6%]
Performing permutations : [33.8%]
Performing permutations : [34.0%]
Performing permutations : [34.2%]
Performing permutations : [34.4%]
Performing permutations : [34.6%]
Performing permutations : [34.8%]
Performing permutations : [35.0%]
Performing permutations : [35.2%]
Performing permutations : [35.4%]
Performing permutations : [35.6%]
Performing permutations : [35.8%]
Performing permutations : [36.0%]
Performing permutations : [36.2%]
Performing permutations : [36.4%]
Performing permutations : [36.6%]
Performing permutations : [36.8%]
Performing permutations : [37.0%]
Performing permutations : [37.2%]
Performing permutations : [37.4%]
Performing permutations : [37.6%]
Performing permutations : [37.8%]
Performing permutations : [38.0%]
Performing permutations : [38.2%]
Performing permutations : [38.4%]
Performing permutations : [38.6%]
Performing permutations : [38.8%]
Performing permutations : [39.0%]
Performing permutations : [39.2%]
Performing permutations : [39.4%]
Performing permutations : [39.6%]
Performing permutations : [39.8%]
Performing permutations : [40.0%]
Performing permutations : [40.2%]
Performing permutations : [40.4%]
Performing permutations : [40.6%]
Performing permutations : [40.8%]
Performing permutations : [41.0%]
Performing permutations : [41.2%]
Performing permutations : [41.4%]
Performing permutations : [41.6%]
Performing permutations : [41.8%]
Performing permutations : [42.0%]
Performing permutations : [42.2%]
Performing permutations : [42.4%]
Performing permutations : [42.6%]
Performing permutations : [42.8%]
Performing permutations : [43.0%]
Performing permutations : [43.2%]
Performing permutations : [43.4%]
Performing permutations : [43.6%]
Performing permutations : [43.8%]
Performing permutations : [44.0%]
Performing permutations : [44.2%]
Performing permutations : [44.4%]
Performing permutations : [44.6%]
Performing permutations : [44.8%]
Performing permutations : [45.0%]
Performing permutations : [45.2%]
Performing permutations : [45.4%]
Performing permutations : [45.6%]
Performing permutations : [45.8%]
Performing permutations : [46.0%]
Performing permutations : [46.2%]
Performing permutations : [46.4%]
Performing permutations : [46.6%]
Performing permutations : [46.8%]
Performing permutations : [47.0%]
Performing permutations : [47.2%]
Performing permutations : [47.4%]
Performing permutations : [47.6%]
Performing permutations : [47.8%]
Performing permutations : [48.0%]
Performing permutations : [48.2%]
Performing permutations : [48.4%]
Performing permutations : [48.6%]
Performing permutations : [48.8%]
Performing permutations : [49.0%]
Performing permutations : [49.2%]
Performing permutations : [49.4%]
Performing permutations : [49.6%]
Performing permutations : [49.8%]
Performing permutations : [50.0%]
Performing permutations : [50.2%]
Performing permutations : [50.4%]
Performing permutations : [50.6%]
Performing permutations : [50.8%]
Performing permutations : [51.0%]
Performing permutations : [51.2%]
Performing permutations : [51.4%]
Performing permutations : [51.6%]
Performing permutations : [51.8%]
Performing permutations : [52.0%]
Performing permutations : [52.2%]
Performing permutations : [52.4%]
Performing permutations : [52.6%]
Performing permutations : [52.8%]
Performing permutations : [53.0%]
Performing permutations : [53.2%]
Performing permutations : [53.4%]
Performing permutations : [53.6%]
Performing permutations : [53.8%]
Performing permutations : [54.0%]
Performing permutations : [54.2%]
Performing permutations : [54.4%]
Performing permutations : [54.6%]
Performing permutations : [54.8%]
Performing permutations : [55.0%]
Performing permutations : [55.2%]
Performing permutations : [55.4%]
Performing permutations : [55.6%]
Performing permutations : [55.8%]
Performing permutations : [56.0%]
Performing permutations : [56.2%]
Performing permutations : [56.4%]
Performing permutations : [56.6%]
Performing permutations : [56.8%]
Performing permutations : [57.0%]
Performing permutations : [57.2%]
Performing permutations : [57.4%]
Performing permutations : [57.6%]
Performing permutations : [57.8%]
Performing permutations : [58.0%]
Performing permutations : [58.2%]
Performing permutations : [58.4%]
Performing permutations : [58.6%]
Performing permutations : [58.8%]
Performing permutations : [59.0%]
Performing permutations : [59.2%]
Performing permutations : [59.4%]
Performing permutations : [59.6%]
Performing permutations : [59.8%]
Performing permutations : [60.0%]
Performing permutations : [60.2%]
Performing permutations : [60.4%]
Performing permutations : [60.6%]
Performing permutations : [60.8%]
Performing permutations : [61.0%]
Performing permutations : [61.2%]
Performing permutations : [61.4%]
Performing permutations : [61.6%]
Performing permutations : [61.8%]
Performing permutations : [62.0%]
Performing permutations : [62.2%]
Performing permutations : [62.4%]
Performing permutations : [62.6%]
Performing permutations : [62.8%]
Performing permutations : [63.0%]
Performing permutations : [63.2%]
Performing permutations : [63.4%]
Performing permutations : [63.6%]
Performing permutations : [63.8%]
Performing permutations : [64.0%]
Performing permutations : [64.2%]
Performing permutations : [64.4%]
Performing permutations : [64.6%]
Performing permutations : [64.8%]
Performing permutations : [65.0%]
Performing permutations : [65.2%]
Performing permutations : [65.4%]
Performing permutations : [65.6%]
Performing permutations : [65.8%]
Performing permutations : [66.0%]
Performing permutations : [66.2%]
Performing permutations : [66.4%]
Performing permutations : [66.6%]
Performing permutations : [66.8%]
Performing permutations : [67.0%]
Performing permutations : [67.2%]
Performing permutations : [67.4%]
Performing permutations : [67.6%]
Performing permutations : [67.8%]
Performing permutations : [68.0%]
Performing permutations : [68.2%]
Performing permutations : [68.4%]
Performing permutations : [68.6%]
Performing permutations : [68.8%]
Performing permutations : [69.0%]
Performing permutations : [69.2%]
Performing permutations : [69.4%]
Performing permutations : [69.6%]
Performing permutations : [69.8%]
Performing permutations : [70.0%]
Performing permutations : [70.2%]
Performing permutations : [70.4%]
Performing permutations : [70.6%]
Performing permutations : [70.8%]
Performing permutations : [71.0%]
Performing permutations : [71.2%]
Performing permutations : [71.4%]
Performing permutations : [71.6%]
Performing permutations : [71.8%]
Performing permutations : [72.0%]
Performing permutations : [72.2%]
Performing permutations : [72.4%]
Performing permutations : [72.6%]
Performing permutations : [72.8%]
Performing permutations : [73.0%]
Performing permutations : [73.2%]
Performing permutations : [73.4%]
Performing permutations : [73.6%]
Performing permutations : [73.8%]
Performing permutations : [74.0%]
Performing permutations : [74.2%]
Performing permutations : [74.4%]
Performing permutations : [74.6%]
Performing permutations : [74.8%]
Performing permutations : [75.0%]
Performing permutations : [75.2%]
Performing permutations : [75.4%]
Performing permutations : [75.6%]
Performing permutations : [75.8%]
Performing permutations : [76.0%]
Performing permutations : [76.2%]
Performing permutations : [76.4%]
Performing permutations : [76.6%]
Performing permutations : [76.8%]
Performing permutations : [77.0%]
Performing permutations : [77.2%]
Performing permutations : [77.4%]
Performing permutations : [77.6%]
Performing permutations : [77.8%]
Performing permutations : [78.0%]
Performing permutations : [78.2%]
Performing permutations : [78.4%]
Performing permutations : [78.6%]
Performing permutations : [78.8%]
Performing permutations : [79.0%]
Performing permutations : [79.2%]
Performing permutations : [79.4%]
Performing permutations : [79.6%]
Performing permutations : [79.8%]
Performing permutations : [80.0%]
Performing permutations : [80.2%]
Performing permutations : [80.4%]
Performing permutations : [80.6%]
Performing permutations : [80.8%]
Performing permutations : [81.0%]
Performing permutations : [81.2%]
Performing permutations : [81.4%]
Performing permutations : [81.6%]
Performing permutations : [81.8%]
Performing permutations : [82.0%]
Performing permutations : [82.2%]
Performing permutations : [82.4%]
Performing permutations : [82.6%]
Performing permutations : [82.8%]
Performing permutations : [83.0%]
Performing permutations : [83.2%]
Performing permutations : [83.4%]
Performing permutations : [83.6%]
Performing permutations : [83.8%]
Performing permutations : [84.0%]
Performing permutations : [84.2%]
Performing permutations : [84.4%]
Performing permutations : [84.6%]
Performing permutations : [84.8%]
Performing permutations : [85.0%]
Performing permutations : [85.2%]
Performing permutations : [85.4%]
Performing permutations : [85.6%]
Performing permutations : [85.8%]
Performing permutations : [86.0%]
Performing permutations : [86.2%]
Performing permutations : [86.4%]
Performing permutations : [86.6%]
Performing permutations : [86.8%]
Performing permutations : [87.0%]
Performing permutations : [87.2%]
Performing permutations : [87.4%]
Performing permutations : [87.6%]
Performing permutations : [87.8%]
Performing permutations : [88.0%]
Performing permutations : [88.2%]
Performing permutations : [88.4%]
Performing permutations : [88.6%]
Performing permutations : [88.8%]
Performing permutations : [89.0%]
Performing permutations : [89.2%]
Performing permutations : [89.4%]
Performing permutations : [89.6%]
Performing permutations : [89.8%]
Performing permutations : [90.0%]
Performing permutations : [90.2%]
Performing permutations : [90.4%]
Performing permutations : [90.6%]
Performing permutations : [90.8%]
Performing permutations : [91.0%]
Performing permutations : [91.2%]
Performing permutations : [91.4%]
Performing permutations : [91.6%]
Performing permutations : [91.8%]
Performing permutations : [92.0%]
Performing permutations : [92.2%]
Performing permutations : [92.4%]
Performing permutations : [92.6%]
Performing permutations : [92.8%]
Performing permutations : [93.0%]
Performing permutations : [93.2%]
Performing permutations : [93.4%]
Performing permutations : [93.6%]
Performing permutations : [93.8%]
Performing permutations : [94.0%]
Performing permutations : [94.2%]
Performing permutations : [94.4%]
Performing permutations : [94.6%]
Performing permutations : [94.8%]
Performing permutations : [95.0%]
Performing permutations : [95.2%]
Performing permutations : [95.4%]
Performing permutations : [95.6%]
Performing permutations : [95.8%]
Performing permutations : [96.0%]
Performing permutations : [96.2%]
Performing permutations : [96.4%]
Performing permutations : [96.6%]
Performing permutations : [96.8%]
Performing permutations : [97.0%]
Performing permutations : [97.2%]
Performing permutations : [97.4%]
Performing permutations : [97.6%]
Performing permutations : [97.8%]
Performing permutations : [98.0%]
Performing permutations : [98.2%]
Performing permutations : [98.4%]
Performing permutations : [98.6%]
Performing permutations : [98.8%]
Performing permutations : [99.0%]
Performing permutations : [99.2%]
Performing permutations : [99.4%]
Performing permutations : [99.6%]
Performing permutations : [99.8%]
p-value: 0.002

t-test distance based permutation test

t_init = time()
p_test = PermutationDistance(n_perms, metric='riemann', mode='ttest')
p, F = p_test.test(covmats, labels)
duration = time() - t_init

fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
p_test.plot(nbins=10, axes=axes)
plt.title('t-test distance - %.2f sec.' % duration)
print('p-value: %.3f' % p)
sns.despine()
plt.tight_layout()
plt.show()

Performing permutations : [0.2%]
Performing permutations : [0.4%]
Performing permutations : [0.6%]
Performing permutations : [0.8%]
Performing permutations : [1.0%]
Performing permutations : [1.2%]
Performing permutations : [1.4%]
Performing permutations : [1.6%]
Performing permutations : [1.8%]
Performing permutations : [2.0%]
Performing permutations : [2.2%]
Performing permutations : [2.4%]
Performing permutations : [2.6%]
Performing permutations : [2.8%]
Performing permutations : [3.0%]
Performing permutations : [3.2%]
Performing permutations : [3.4%]
Performing permutations : [3.6%]
Performing permutations : [3.8%]
Performing permutations : [4.0%]
Performing permutations : [4.2%]
Performing permutations : [4.4%]
Performing permutations : [4.6%]
Performing permutations : [4.8%]
Performing permutations : [5.0%]
Performing permutations : [5.2%]
Performing permutations : [5.4%]
Performing permutations : [5.6%]
Performing permutations : [5.8%]
Performing permutations : [6.0%]
Performing permutations : [6.2%]
Performing permutations : [6.4%]
Performing permutations : [6.6%]
Performing permutations : [6.8%]
Performing permutations : [7.0%]
Performing permutations : [7.2%]
Performing permutations : [7.4%]
Performing permutations : [7.6%]
Performing permutations : [7.8%]
Performing permutations : [8.0%]
Performing permutations : [8.2%]
Performing permutations : [8.4%]
Performing permutations : [8.6%]
Performing permutations : [8.8%]
Performing permutations : [9.0%]
Performing permutations : [9.2%]
Performing permutations : [9.4%]
Performing permutations : [9.6%]
Performing permutations : [9.8%]
Performing permutations : [10.0%]
Performing permutations : [10.2%]
Performing permutations : [10.4%]
Performing permutations : [10.6%]
Performing permutations : [10.8%]
Performing permutations : [11.0%]
Performing permutations : [11.2%]
Performing permutations : [11.4%]
Performing permutations : [11.6%]
Performing permutations : [11.8%]
Performing permutations : [12.0%]
Performing permutations : [12.2%]
Performing permutations : [12.4%]
Performing permutations : [12.6%]
Performing permutations : [12.8%]
Performing permutations : [13.0%]
Performing permutations : [13.2%]
Performing permutations : [13.4%]
Performing permutations : [13.6%]
Performing permutations : [13.8%]
Performing permutations : [14.0%]
Performing permutations : [14.2%]
Performing permutations : [14.4%]
Performing permutations : [14.6%]
Performing permutations : [14.8%]
Performing permutations : [15.0%]
Performing permutations : [15.2%]
Performing permutations : [15.4%]
Performing permutations : [15.6%]
Performing permutations : [15.8%]
Performing permutations : [16.0%]
Performing permutations : [16.2%]
Performing permutations : [16.4%]
Performing permutations : [16.6%]
Performing permutations : [16.8%]
Performing permutations : [17.0%]
Performing permutations : [17.2%]
Performing permutations : [17.4%]
Performing permutations : [17.6%]
Performing permutations : [17.8%]
Performing permutations : [18.0%]
Performing permutations : [18.2%]
Performing permutations : [18.4%]
Performing permutations : [18.6%]
Performing permutations : [18.8%]
Performing permutations : [19.0%]
Performing permutations : [19.2%]
Performing permutations : [19.4%]
Performing permutations : [19.6%]
Performing permutations : [19.8%]
Performing permutations : [20.0%]
Performing permutations : [20.2%]
Performing permutations : [20.4%]
Performing permutations : [20.6%]
Performing permutations : [20.8%]
Performing permutations : [21.0%]
Performing permutations : [21.2%]
Performing permutations : [21.4%]
Performing permutations : [21.6%]
Performing permutations : [21.8%]
Performing permutations : [22.0%]
Performing permutations : [22.2%]
Performing permutations : [22.4%]
Performing permutations : [22.6%]
Performing permutations : [22.8%]
Performing permutations : [23.0%]
Performing permutations : [23.2%]
Performing permutations : [23.4%]
Performing permutations : [23.6%]
Performing permutations : [23.8%]
Performing permutations : [24.0%]
Performing permutations : [24.2%]
Performing permutations : [24.4%]
Performing permutations : [24.6%]
Performing permutations : [24.8%]
Performing permutations : [25.0%]
Performing permutations : [25.2%]
Performing permutations : [25.4%]
Performing permutations : [25.6%]
Performing permutations : [25.8%]
Performing permutations : [26.0%]
Performing permutations : [26.2%]
Performing permutations : [26.4%]
Performing permutations : [26.6%]
Performing permutations : [26.8%]
Performing permutations : [27.0%]
Performing permutations : [27.2%]
Performing permutations : [27.4%]
Performing permutations : [27.6%]
Performing permutations : [27.8%]
Performing permutations : [28.0%]
Performing permutations : [28.2%]
Performing permutations : [28.4%]
Performing permutations : [28.6%]
Performing permutations : [28.8%]
Performing permutations : [29.0%]
Performing permutations : [29.2%]
Performing permutations : [29.4%]
Performing permutations : [29.6%]
Performing permutations : [29.8%]
Performing permutations : [30.0%]
Performing permutations : [30.2%]
Performing permutations : [30.4%]
Performing permutations : [30.6%]
Performing permutations : [30.8%]
Performing permutations : [31.0%]
Performing permutations : [31.2%]
Performing permutations : [31.4%]
Performing permutations : [31.6%]
Performing permutations : [31.8%]
Performing permutations : [32.0%]
Performing permutations : [32.2%]
Performing permutations : [32.4%]
Performing permutations : [32.6%]
Performing permutations : [32.8%]
Performing permutations : [33.0%]
Performing permutations : [33.2%]
Performing permutations : [33.4%]
Performing permutations : [33.6%]
Performing permutations : [33.8%]
Performing permutations : [34.0%]
Performing permutations : [34.2%]
Performing permutations : [34.4%]
Performing permutations : [34.6%]
Performing permutations : [34.8%]
Performing permutations : [35.0%]
Performing permutations : [35.2%]
Performing permutations : [35.4%]
Performing permutations : [35.6%]
Performing permutations : [35.8%]
Performing permutations : [36.0%]
Performing permutations : [36.2%]
Performing permutations : [36.4%]
Performing permutations : [36.6%]
Performing permutations : [36.8%]
Performing permutations : [37.0%]
Performing permutations : [37.2%]
Performing permutations : [37.4%]
Performing permutations : [37.6%]
Performing permutations : [37.8%]
Performing permutations : [38.0%]
Performing permutations : [38.2%]
Performing permutations : [38.4%]
Performing permutations : [38.6%]
Performing permutations : [38.8%]
Performing permutations : [39.0%]
Performing permutations : [39.2%]
Performing permutations : [39.4%]
Performing permutations : [39.6%]
Performing permutations : [39.8%]
Performing permutations : [40.0%]
Performing permutations : [40.2%]
Performing permutations : [40.4%]
Performing permutations : [40.6%]
Performing permutations : [40.8%]
Performing permutations : [41.0%]
Performing permutations : [41.2%]
Performing permutations : [41.4%]
Performing permutations : [41.6%]
Performing permutations : [41.8%]
Performing permutations : [42.0%]
Performing permutations : [42.2%]
Performing permutations : [42.4%]
Performing permutations : [42.6%]
Performing permutations : [42.8%]
Performing permutations : [43.0%]
Performing permutations : [43.2%]
Performing permutations : [43.4%]
Performing permutations : [43.6%]
Performing permutations : [43.8%]
Performing permutations : [44.0%]
Performing permutations : [44.2%]
Performing permutations : [44.4%]
Performing permutations : [44.6%]
Performing permutations : [44.8%]
Performing permutations : [45.0%]
Performing permutations : [45.2%]
Performing permutations : [45.4%]
Performing permutations : [45.6%]
Performing permutations : [45.8%]
Performing permutations : [46.0%]
Performing permutations : [46.2%]
Performing permutations : [46.4%]
Performing permutations : [46.6%]
Performing permutations : [46.8%]
Performing permutations : [47.0%]
Performing permutations : [47.2%]
Performing permutations : [47.4%]
Performing permutations : [47.6%]
Performing permutations : [47.8%]
Performing permutations : [48.0%]
Performing permutations : [48.2%]
Performing permutations : [48.4%]
Performing permutations : [48.6%]
Performing permutations : [48.8%]
Performing permutations : [49.0%]
Performing permutations : [49.2%]
Performing permutations : [49.4%]
Performing permutations : [49.6%]
Performing permutations : [49.8%]
Performing permutations : [50.0%]
Performing permutations : [50.2%]
Performing permutations : [50.4%]
Performing permutations : [50.6%]
Performing permutations : [50.8%]
Performing permutations : [51.0%]
Performing permutations : [51.2%]
Performing permutations : [51.4%]
Performing permutations : [51.6%]
Performing permutations : [51.8%]
Performing permutations : [52.0%]
Performing permutations : [52.2%]
Performing permutations : [52.4%]
Performing permutations : [52.6%]
Performing permutations : [52.8%]
Performing permutations : [53.0%]
Performing permutations : [53.2%]
Performing permutations : [53.4%]
Performing permutations : [53.6%]
Performing permutations : [53.8%]
Performing permutations : [54.0%]
Performing permutations : [54.2%]
Performing permutations : [54.4%]
Performing permutations : [54.6%]
Performing permutations : [54.8%]
Performing permutations : [55.0%]
Performing permutations : [55.2%]
Performing permutations : [55.4%]
Performing permutations : [55.6%]
Performing permutations : [55.8%]
Performing permutations : [56.0%]
Performing permutations : [56.2%]
Performing permutations : [56.4%]
Performing permutations : [56.6%]
Performing permutations : [56.8%]
Performing permutations : [57.0%]
Performing permutations : [57.2%]
Performing permutations : [57.4%]
Performing permutations : [57.6%]
Performing permutations : [57.8%]
Performing permutations : [58.0%]
Performing permutations : [58.2%]
Performing permutations : [58.4%]
Performing permutations : [58.6%]
Performing permutations : [58.8%]
Performing permutations : [59.0%]
Performing permutations : [59.2%]
Performing permutations : [59.4%]
Performing permutations : [59.6%]
Performing permutations : [59.8%]
Performing permutations : [60.0%]
Performing permutations : [60.2%]
Performing permutations : [60.4%]
Performing permutations : [60.6%]
Performing permutations : [60.8%]
Performing permutations : [61.0%]
Performing permutations : [61.2%]
Performing permutations : [61.4%]
Performing permutations : [61.6%]
Performing permutations : [61.8%]
Performing permutations : [62.0%]
Performing permutations : [62.2%]
Performing permutations : [62.4%]
Performing permutations : [62.6%]
Performing permutations : [62.8%]
Performing permutations : [63.0%]
Performing permutations : [63.2%]
Performing permutations : [63.4%]
Performing permutations : [63.6%]
Performing permutations : [63.8%]
Performing permutations : [64.0%]
Performing permutations : [64.2%]
Performing permutations : [64.4%]
Performing permutations : [64.6%]
Performing permutations : [64.8%]
Performing permutations : [65.0%]
Performing permutations : [65.2%]
Performing permutations : [65.4%]
Performing permutations : [65.6%]
Performing permutations : [65.8%]
Performing permutations : [66.0%]
Performing permutations : [66.2%]
Performing permutations : [66.4%]
Performing permutations : [66.6%]
Performing permutations : [66.8%]
Performing permutations : [67.0%]
Performing permutations : [67.2%]
Performing permutations : [67.4%]
Performing permutations : [67.6%]
Performing permutations : [67.8%]
Performing permutations : [68.0%]
Performing permutations : [68.2%]
Performing permutations : [68.4%]
Performing permutations : [68.6%]
Performing permutations : [68.8%]
Performing permutations : [69.0%]
Performing permutations : [69.2%]
Performing permutations : [69.4%]
Performing permutations : [69.6%]
Performing permutations : [69.8%]
Performing permutations : [70.0%]
Performing permutations : [70.2%]
Performing permutations : [70.4%]
Performing permutations : [70.6%]
Performing permutations : [70.8%]
Performing permutations : [71.0%]
Performing permutations : [71.2%]
Performing permutations : [71.4%]
Performing permutations : [71.6%]
Performing permutations : [71.8%]
Performing permutations : [72.0%]
Performing permutations : [72.2%]
Performing permutations : [72.4%]
Performing permutations : [72.6%]
Performing permutations : [72.8%]
Performing permutations : [73.0%]
Performing permutations : [73.2%]
Performing permutations : [73.4%]
Performing permutations : [73.6%]
Performing permutations : [73.8%]
Performing permutations : [74.0%]
Performing permutations : [74.2%]
Performing permutations : [74.4%]
Performing permutations : [74.6%]
Performing permutations : [74.8%]
Performing permutations : [75.0%]
Performing permutations : [75.2%]
Performing permutations : [75.4%]
Performing permutations : [75.6%]
Performing permutations : [75.8%]
Performing permutations : [76.0%]
Performing permutations : [76.2%]
Performing permutations : [76.4%]
Performing permutations : [76.6%]
Performing permutations : [76.8%]
Performing permutations : [77.0%]
Performing permutations : [77.2%]
Performing permutations : [77.4%]
Performing permutations : [77.6%]
Performing permutations : [77.8%]
Performing permutations : [78.0%]
Performing permutations : [78.2%]
Performing permutations : [78.4%]
Performing permutations : [78.6%]
Performing permutations : [78.8%]
Performing permutations : [79.0%]
Performing permutations : [79.2%]
Performing permutations : [79.4%]
Performing permutations : [79.6%]
Performing permutations : [79.8%]
Performing permutations : [80.0%]
Performing permutations : [80.2%]
Performing permutations : [80.4%]
Performing permutations : [80.6%]
Performing permutations : [80.8%]
Performing permutations : [81.0%]
Performing permutations : [81.2%]
Performing permutations : [81.4%]
Performing permutations : [81.6%]
Performing permutations : [81.8%]
Performing permutations : [82.0%]
Performing permutations : [82.2%]
Performing permutations : [82.4%]
Performing permutations : [82.6%]
Performing permutations : [82.8%]
Performing permutations : [83.0%]
Performing permutations : [83.2%]
Performing permutations : [83.4%]
Performing permutations : [83.6%]
Performing permutations : [83.8%]
Performing permutations : [84.0%]
Performing permutations : [84.2%]
Performing permutations : [84.4%]
Performing permutations : [84.6%]
Performing permutations : [84.8%]
Performing permutations : [85.0%]
Performing permutations : [85.2%]
Performing permutations : [85.4%]
Performing permutations : [85.6%]
Performing permutations : [85.8%]
Performing permutations : [86.0%]
Performing permutations : [86.2%]
Performing permutations : [86.4%]
Performing permutations : [86.6%]
Performing permutations : [86.8%]
Performing permutations : [87.0%]
Performing permutations : [87.2%]
Performing permutations : [87.4%]
Performing permutations : [87.6%]
Performing permutations : [87.8%]
Performing permutations : [88.0%]
Performing permutations : [88.2%]
Performing permutations : [88.4%]
Performing permutations : [88.6%]
Performing permutations : [88.8%]
Performing permutations : [89.0%]
Performing permutations : [89.2%]
Performing permutations : [89.4%]
Performing permutations : [89.6%]
Performing permutations : [89.8%]
Performing permutations : [90.0%]
Performing permutations : [90.2%]
Performing permutations : [90.4%]
Performing permutations : [90.6%]
Performing permutations : [90.8%]
Performing permutations : [91.0%]
Performing permutations : [91.2%]
Performing permutations : [91.4%]
Performing permutations : [91.6%]
Performing permutations : [91.8%]
Performing permutations : [92.0%]
Performing permutations : [92.2%]
Performing permutations : [92.4%]
Performing permutations : [92.6%]
Performing permutations : [92.8%]
Performing permutations : [93.0%]
Performing permutations : [93.2%]
Performing permutations : [93.4%]
Performing permutations : [93.6%]
Performing permutations : [93.8%]
Performing permutations : [94.0%]
Performing permutations : [94.2%]
Performing permutations : [94.4%]
Performing permutations : [94.6%]
Performing permutations : [94.8%]
Performing permutations : [95.0%]
Performing permutations : [95.2%]
Performing permutations : [95.4%]
Performing permutations : [95.6%]
Performing permutations : [95.8%]
Performing permutations : [96.0%]
Performing permutations : [96.2%]
Performing permutations : [96.4%]
Performing permutations : [96.6%]
Performing permutations : [96.8%]
Performing permutations : [97.0%]
Performing permutations : [97.2%]
Performing permutations : [97.4%]
Performing permutations : [97.6%]
Performing permutations : [97.8%]
Performing permutations : [98.0%]
Performing permutations : [98.2%]
Performing permutations : [98.4%]
Performing permutations : [98.6%]
Performing permutations : [98.8%]
Performing permutations : [99.0%]
Performing permutations : [99.2%]
Performing permutations : [99.4%]
Performing permutations : [99.6%]
Performing permutations : [99.8%]
p-value: 0.002

F-test distance based permutation test

t_init = time()
p_test = PermutationDistance(n_perms, metric='riemann', mode='ftest')
p, F = p_test.test(covmats, labels)
duration = time() - t_init

fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
p_test.plot(nbins=10, axes=axes)
plt.title('F-test distance - %.2f sec.' % duration)
print('p-value: %.3f' % p)
sns.despine()
plt.tight_layout()
plt.show()

Performing permutations : [0.2%]
Performing permutations : [0.4%]
Performing permutations : [0.6%]
Performing permutations : [0.8%]
Performing permutations : [1.0%]
Performing permutations : [1.2%]
Performing permutations : [1.4%]
Performing permutations : [1.6%]
Performing permutations : [1.8%]
Performing permutations : [2.0%]
Performing permutations : [2.2%]
Performing permutations : [2.4%]
Performing permutations : [2.6%]
Performing permutations : [2.8%]
Performing permutations : [3.0%]
Performing permutations : [3.2%]
Performing permutations : [3.4%]
Performing permutations : [3.6%]
Performing permutations : [3.8%]
Performing permutations : [4.0%]
Performing permutations : [4.2%]
Performing permutations : [4.4%]
Performing permutations : [4.6%]
Performing permutations : [4.8%]
Performing permutations : [5.0%]
Performing permutations : [5.2%]
Performing permutations : [5.4%]
Performing permutations : [5.6%]
Performing permutations : [5.8%]
Performing permutations : [6.0%]
Performing permutations : [6.2%]
Performing permutations : [6.4%]
Performing permutations : [6.6%]
Performing permutations : [6.8%]
Performing permutations : [7.0%]
Performing permutations : [7.2%]
Performing permutations : [7.4%]
Performing permutations : [7.6%]
Performing permutations : [7.8%]
Performing permutations : [8.0%]
Performing permutations : [8.2%]
Performing permutations : [8.4%]
Performing permutations : [8.6%]
Performing permutations : [8.8%]
Performing permutations : [9.0%]
Performing permutations : [9.2%]
Performing permutations : [9.4%]
Performing permutations : [9.6%]
Performing permutations : [9.8%]
Performing permutations : [10.0%]
Performing permutations : [10.2%]
Performing permutations : [10.4%]
Performing permutations : [10.6%]
Performing permutations : [10.8%]
Performing permutations : [11.0%]
Performing permutations : [11.2%]
Performing permutations : [11.4%]
Performing permutations : [11.6%]
Performing permutations : [11.8%]
Performing permutations : [12.0%]
Performing permutations : [12.2%]
Performing permutations : [12.4%]
Performing permutations : [12.6%]
Performing permutations : [12.8%]
Performing permutations : [13.0%]
Performing permutations : [13.2%]
Performing permutations : [13.4%]
Performing permutations : [13.6%]
Performing permutations : [13.8%]
Performing permutations : [14.0%]
Performing permutations : [14.2%]
Performing permutations : [14.4%]
Performing permutations : [14.6%]
Performing permutations : [14.8%]
Performing permutations : [15.0%]
Performing permutations : [15.2%]
Performing permutations : [15.4%]
Performing permutations : [15.6%]
Performing permutations : [15.8%]
Performing permutations : [16.0%]
Performing permutations : [16.2%]
Performing permutations : [16.4%]
Performing permutations : [16.6%]
Performing permutations : [16.8%]
Performing permutations : [17.0%]
Performing permutations : [17.2%]
Performing permutations : [17.4%]
Performing permutations : [17.6%]
Performing permutations : [17.8%]
Performing permutations : [18.0%]
Performing permutations : [18.2%]
Performing permutations : [18.4%]
Performing permutations : [18.6%]
Performing permutations : [18.8%]
Performing permutations : [19.0%]
Performing permutations : [19.2%]
Performing permutations : [19.4%]
Performing permutations : [19.6%]
Performing permutations : [19.8%]
Performing permutations : [20.0%]
Performing permutations : [20.2%]
Performing permutations : [20.4%]
Performing permutations : [20.6%]
Performing permutations : [20.8%]
Performing permutations : [21.0%]
Performing permutations : [21.2%]
Performing permutations : [21.4%]
Performing permutations : [21.6%]
Performing permutations : [21.8%]
Performing permutations : [22.0%]
Performing permutations : [22.2%]
Performing permutations : [22.4%]
Performing permutations : [22.6%]
Performing permutations : [22.8%]
Performing permutations : [23.0%]
Performing permutations : [23.2%]
Performing permutations : [23.4%]
Performing permutations : [23.6%]
Performing permutations : [23.8%]
Performing permutations : [24.0%]
Performing permutations : [24.2%]
Performing permutations : [24.4%]
Performing permutations : [24.6%]
Performing permutations : [24.8%]
Performing permutations : [25.0%]
Performing permutations : [25.2%]
Performing permutations : [25.4%]
Performing permutations : [25.6%]
Performing permutations : [25.8%]
Performing permutations : [26.0%]
Performing permutations : [26.2%]
Performing permutations : [26.4%]
Performing permutations : [26.6%]
Performing permutations : [26.8%]
Performing permutations : [27.0%]
Performing permutations : [27.2%]
Performing permutations : [27.4%]
Performing permutations : [27.6%]
Performing permutations : [27.8%]
Performing permutations : [28.0%]
Performing permutations : [28.2%]
Performing permutations : [28.4%]
Performing permutations : [28.6%]
Performing permutations : [28.8%]
Performing permutations : [29.0%]
Performing permutations : [29.2%]
Performing permutations : [29.4%]
Performing permutations : [29.6%]
Performing permutations : [29.8%]
Performing permutations : [30.0%]
Performing permutations : [30.2%]
Performing permutations : [30.4%]
Performing permutations : [30.6%]
Performing permutations : [30.8%]
Performing permutations : [31.0%]
Performing permutations : [31.2%]
Performing permutations : [31.4%]
Performing permutations : [31.6%]
Performing permutations : [31.8%]
Performing permutations : [32.0%]
Performing permutations : [32.2%]
Performing permutations : [32.4%]
Performing permutations : [32.6%]
Performing permutations : [32.8%]
Performing permutations : [33.0%]
Performing permutations : [33.2%]
Performing permutations : [33.4%]
Performing permutations : [33.6%]
Performing permutations : [33.8%]
Performing permutations : [34.0%]
Performing permutations : [34.2%]
Performing permutations : [34.4%]
Performing permutations : [34.6%]
Performing permutations : [34.8%]
Performing permutations : [35.0%]
Performing permutations : [35.2%]
Performing permutations : [35.4%]
Performing permutations : [35.6%]
Performing permutations : [35.8%]
Performing permutations : [36.0%]
Performing permutations : [36.2%]
Performing permutations : [36.4%]
Performing permutations : [36.6%]
Performing permutations : [36.8%]
Performing permutations : [37.0%]
Performing permutations : [37.2%]
Performing permutations : [37.4%]
Performing permutations : [37.6%]
Performing permutations : [37.8%]
Performing permutations : [38.0%]
Performing permutations : [38.2%]
Performing permutations : [38.4%]
Performing permutations : [38.6%]
Performing permutations : [38.8%]
Performing permutations : [39.0%]
Performing permutations : [39.2%]
Performing permutations : [39.4%]
Performing permutations : [39.6%]
Performing permutations : [39.8%]
Performing permutations : [40.0%]
Performing permutations : [40.2%]
Performing permutations : [40.4%]
Performing permutations : [40.6%]
Performing permutations : [40.8%]
Performing permutations : [41.0%]
Performing permutations : [41.2%]
Performing permutations : [41.4%]
Performing permutations : [41.6%]
Performing permutations : [41.8%]
Performing permutations : [42.0%]
Performing permutations : [42.2%]
Performing permutations : [42.4%]
Performing permutations : [42.6%]
Performing permutations : [42.8%]
Performing permutations : [43.0%]
Performing permutations : [43.2%]
Performing permutations : [43.4%]
Performing permutations : [43.6%]
Performing permutations : [43.8%]
Performing permutations : [44.0%]
Performing permutations : [44.2%]
Performing permutations : [44.4%]
Performing permutations : [44.6%]
Performing permutations : [44.8%]
Performing permutations : [45.0%]
Performing permutations : [45.2%]
Performing permutations : [45.4%]
Performing permutations : [45.6%]
Performing permutations : [45.8%]
Performing permutations : [46.0%]
Performing permutations : [46.2%]
Performing permutations : [46.4%]
Performing permutations : [46.6%]
Performing permutations : [46.8%]
Performing permutations : [47.0%]
Performing permutations : [47.2%]
Performing permutations : [47.4%]
Performing permutations : [47.6%]
Performing permutations : [47.8%]
Performing permutations : [48.0%]
Performing permutations : [48.2%]
Performing permutations : [48.4%]
Performing permutations : [48.6%]
Performing permutations : [48.8%]
Performing permutations : [49.0%]
Performing permutations : [49.2%]
Performing permutations : [49.4%]
Performing permutations : [49.6%]
Performing permutations : [49.8%]
Performing permutations : [50.0%]
Performing permutations : [50.2%]
Performing permutations : [50.4%]
Performing permutations : [50.6%]
Performing permutations : [50.8%]
Performing permutations : [51.0%]
Performing permutations : [51.2%]
Performing permutations : [51.4%]
Performing permutations : [51.6%]
Performing permutations : [51.8%]
Performing permutations : [52.0%]
Performing permutations : [52.2%]
Performing permutations : [52.4%]
Performing permutations : [52.6%]
Performing permutations : [52.8%]
Performing permutations : [53.0%]
Performing permutations : [53.2%]
Performing permutations : [53.4%]
Performing permutations : [53.6%]
Performing permutations : [53.8%]
Performing permutations : [54.0%]
Performing permutations : [54.2%]
Performing permutations : [54.4%]
Performing permutations : [54.6%]
Performing permutations : [54.8%]
Performing permutations : [55.0%]
Performing permutations : [55.2%]
Performing permutations : [55.4%]
Performing permutations : [55.6%]
Performing permutations : [55.8%]
Performing permutations : [56.0%]
Performing permutations : [56.2%]
Performing permutations : [56.4%]
Performing permutations : [56.6%]
Performing permutations : [56.8%]
Performing permutations : [57.0%]
Performing permutations : [57.2%]
Performing permutations : [57.4%]
Performing permutations : [57.6%]
Performing permutations : [57.8%]
Performing permutations : [58.0%]
Performing permutations : [58.2%]
Performing permutations : [58.4%]
Performing permutations : [58.6%]
Performing permutations : [58.8%]
Performing permutations : [59.0%]
Performing permutations : [59.2%]
Performing permutations : [59.4%]
Performing permutations : [59.6%]
Performing permutations : [59.8%]
Performing permutations : [60.0%]
Performing permutations : [60.2%]
Performing permutations : [60.4%]
Performing permutations : [60.6%]
Performing permutations : [60.8%]
Performing permutations : [61.0%]
Performing permutations : [61.2%]
Performing permutations : [61.4%]
Performing permutations : [61.6%]
Performing permutations : [61.8%]
Performing permutations : [62.0%]
Performing permutations : [62.2%]
Performing permutations : [62.4%]
Performing permutations : [62.6%]
Performing permutations : [62.8%]
Performing permutations : [63.0%]
Performing permutations : [63.2%]
Performing permutations : [63.4%]
Performing permutations : [63.6%]
Performing permutations : [63.8%]
Performing permutations : [64.0%]
Performing permutations : [64.2%]
Performing permutations : [64.4%]
Performing permutations : [64.6%]
Performing permutations : [64.8%]
Performing permutations : [65.0%]
Performing permutations : [65.2%]
Performing permutations : [65.4%]
Performing permutations : [65.6%]
Performing permutations : [65.8%]
Performing permutations : [66.0%]
Performing permutations : [66.2%]
Performing permutations : [66.4%]
Performing permutations : [66.6%]
Performing permutations : [66.8%]
Performing permutations : [67.0%]
Performing permutations : [67.2%]
Performing permutations : [67.4%]
Performing permutations : [67.6%]
Performing permutations : [67.8%]
Performing permutations : [68.0%]
Performing permutations : [68.2%]
Performing permutations : [68.4%]
Performing permutations : [68.6%]
Performing permutations : [68.8%]
Performing permutations : [69.0%]
Performing permutations : [69.2%]
Performing permutations : [69.4%]
Performing permutations : [69.6%]
Performing permutations : [69.8%]
Performing permutations : [70.0%]
Performing permutations : [70.2%]
Performing permutations : [70.4%]
Performing permutations : [70.6%]
Performing permutations : [70.8%]
Performing permutations : [71.0%]
Performing permutations : [71.2%]
Performing permutations : [71.4%]
Performing permutations : [71.6%]
Performing permutations : [71.8%]
Performing permutations : [72.0%]
Performing permutations : [72.2%]
Performing permutations : [72.4%]
Performing permutations : [72.6%]
Performing permutations : [72.8%]
Performing permutations : [73.0%]
Performing permutations : [73.2%]
Performing permutations : [73.4%]
Performing permutations : [73.6%]
Performing permutations : [73.8%]
Performing permutations : [74.0%]
Performing permutations : [74.2%]
Performing permutations : [74.4%]
Performing permutations : [74.6%]
Performing permutations : [74.8%]
Performing permutations : [75.0%]
Performing permutations : [75.2%]
Performing permutations : [75.4%]
Performing permutations : [75.6%]
Performing permutations : [75.8%]
Performing permutations : [76.0%]
Performing permutations : [76.2%]
Performing permutations : [76.4%]
Performing permutations : [76.6%]
Performing permutations : [76.8%]
Performing permutations : [77.0%]
Performing permutations : [77.2%]
Performing permutations : [77.4%]
Performing permutations : [77.6%]
Performing permutations : [77.8%]
Performing permutations : [78.0%]
Performing permutations : [78.2%]
Performing permutations : [78.4%]
Performing permutations : [78.6%]
Performing permutations : [78.8%]
Performing permutations : [79.0%]
Performing permutations : [79.2%]
Performing permutations : [79.4%]
Performing permutations : [79.6%]
Performing permutations : [79.8%]
Performing permutations : [80.0%]
Performing permutations : [80.2%]
Performing permutations : [80.4%]
Performing permutations : [80.6%]
Performing permutations : [80.8%]
Performing permutations : [81.0%]
Performing permutations : [81.2%]
Performing permutations : [81.4%]
Performing permutations : [81.6%]
Performing permutations : [81.8%]
Performing permutations : [82.0%]
Performing permutations : [82.2%]
Performing permutations : [82.4%]
Performing permutations : [82.6%]
Performing permutations : [82.8%]
Performing permutations : [83.0%]
Performing permutations : [83.2%]
Performing permutations : [83.4%]
Performing permutations : [83.6%]
Performing permutations : [83.8%]
Performing permutations : [84.0%]
Performing permutations : [84.2%]
Performing permutations : [84.4%]
Performing permutations : [84.6%]
Performing permutations : [84.8%]
Performing permutations : [85.0%]
Performing permutations : [85.2%]
Performing permutations : [85.4%]
Performing permutations : [85.6%]
Performing permutations : [85.8%]
Performing permutations : [86.0%]
Performing permutations : [86.2%]
Performing permutations : [86.4%]
Performing permutations : [86.6%]
Performing permutations : [86.8%]
Performing permutations : [87.0%]
Performing permutations : [87.2%]
Performing permutations : [87.4%]
Performing permutations : [87.6%]
Performing permutations : [87.8%]
Performing permutations : [88.0%]
Performing permutations : [88.2%]
Performing permutations : [88.4%]
Performing permutations : [88.6%]
Performing permutations : [88.8%]
Performing permutations : [89.0%]
Performing permutations : [89.2%]
Performing permutations : [89.4%]
Performing permutations : [89.6%]
Performing permutations : [89.8%]
Performing permutations : [90.0%]
Performing permutations : [90.2%]
Performing permutations : [90.4%]
Performing permutations : [90.6%]
Performing permutations : [90.8%]
Performing permutations : [91.0%]
Performing permutations : [91.2%]
Performing permutations : [91.4%]
Performing permutations : [91.6%]
Performing permutations : [91.8%]
Performing permutations : [92.0%]
Performing permutations : [92.2%]
Performing permutations : [92.4%]
Performing permutations : [92.6%]
Performing permutations : [92.8%]
Performing permutations : [93.0%]
Performing permutations : [93.2%]
Performing permutations : [93.4%]
Performing permutations : [93.6%]
Performing permutations : [93.8%]
Performing permutations : [94.0%]
Performing permutations : [94.2%]
Performing permutations : [94.4%]
Performing permutations : [94.6%]
Performing permutations : [94.8%]
Performing permutations : [95.0%]
Performing permutations : [95.2%]
Performing permutations : [95.4%]
Performing permutations : [95.6%]
Performing permutations : [95.8%]
Performing permutations : [96.0%]
Performing permutations : [96.2%]
Performing permutations : [96.4%]
Performing permutations : [96.6%]
Performing permutations : [96.8%]
Performing permutations : [97.0%]
Performing permutations : [97.2%]
Performing permutations : [97.4%]
Performing permutations : [97.6%]
Performing permutations : [97.8%]
Performing permutations : [98.0%]
Performing permutations : [98.2%]
Performing permutations : [98.4%]
Performing permutations : [98.6%]
Performing permutations : [98.8%]
Performing permutations : [99.0%]
Performing permutations : [99.2%]
Performing permutations : [99.4%]
Performing permutations : [99.6%]
Performing permutations : [99.8%]
p-value: 0.002

Classification based permutation test

clf = make_pipeline(CSP(4), LogisticRegression())

t_init = time()
p_test = PermutationModel(n_perms, model=clf, cv=3, scoring='roc_auc')
p, F = p_test.test(covmats, labels)
duration = time() - t_init

fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
p_test.plot(nbins=10, axes=axes)
plt.title('Classification - %.2f sec.' % duration)
print('p-value: %.3f' % p)
sns.despine()
plt.tight_layout()
plt.show()

Performing permutations : [0.2%]
Performing permutations : [0.4%]
Performing permutations : [0.6%]
Performing permutations : [0.8%]
Performing permutations : [1.0%]
Performing permutations : [1.2%]
Performing permutations : [1.4%]
Performing permutations : [1.6%]
Performing permutations : [1.8%]
Performing permutations : [2.0%]
Performing permutations : [2.2%]
Performing permutations : [2.4%]
Performing permutations : [2.6%]
Performing permutations : [2.8%]
Performing permutations : [3.0%]
Performing permutations : [3.2%]
Performing permutations : [3.4%]
Performing permutations : [3.6%]
Performing permutations : [3.8%]
Performing permutations : [4.0%]
Performing permutations : [4.2%]
Performing permutations : [4.4%]
Performing permutations : [4.6%]
Performing permutations : [4.8%]
Performing permutations : [5.0%]
Performing permutations : [5.2%]
Performing permutations : [5.4%]
Performing permutations : [5.6%]
Performing permutations : [5.8%]
Performing permutations : [6.0%]
Performing permutations : [6.2%]
Performing permutations : [6.4%]
Performing permutations : [6.6%]
Performing permutations : [6.8%]
Performing permutations : [7.0%]
Performing permutations : [7.2%]
Performing permutations : [7.4%]
Performing permutations : [7.6%]
Performing permutations : [7.8%]
Performing permutations : [8.0%]
Performing permutations : [8.2%]
Performing permutations : [8.4%]
Performing permutations : [8.6%]
Performing permutations : [8.8%]
Performing permutations : [9.0%]
Performing permutations : [9.2%]
Performing permutations : [9.4%]
Performing permutations : [9.6%]
Performing permutations : [9.8%]
Performing permutations : [10.0%]
Performing permutations : [10.2%]
Performing permutations : [10.4%]
Performing permutations : [10.6%]
Performing permutations : [10.8%]
Performing permutations : [11.0%]
Performing permutations : [11.2%]
Performing permutations : [11.4%]
Performing permutations : [11.6%]
Performing permutations : [11.8%]
Performing permutations : [12.0%]
Performing permutations : [12.2%]
Performing permutations : [12.4%]
Performing permutations : [12.6%]
Performing permutations : [12.8%]
Performing permutations : [13.0%]
Performing permutations : [13.2%]
Performing permutations : [13.4%]
Performing permutations : [13.6%]
Performing permutations : [13.8%]
Performing permutations : [14.0%]
Performing permutations : [14.2%]
Performing permutations : [14.4%]
Performing permutations : [14.6%]
Performing permutations : [14.8%]
Performing permutations : [15.0%]
Performing permutations : [15.2%]
Performing permutations : [15.4%]
Performing permutations : [15.6%]
Performing permutations : [15.8%]
Performing permutations : [16.0%]
Performing permutations : [16.2%]
Performing permutations : [16.4%]
Performing permutations : [16.6%]
Performing permutations : [16.8%]
Performing permutations : [17.0%]
Performing permutations : [17.2%]
Performing permutations : [17.4%]
Performing permutations : [17.6%]
Performing permutations : [17.8%]
Performing permutations : [18.0%]
Performing permutations : [18.2%]
Performing permutations : [18.4%]
Performing permutations : [18.6%]
Performing permutations : [18.8%]
Performing permutations : [19.0%]
Performing permutations : [19.2%]
Performing permutations : [19.4%]
Performing permutations : [19.6%]
Performing permutations : [19.8%]
Performing permutations : [20.0%]
Performing permutations : [20.2%]
Performing permutations : [20.4%]
Performing permutations : [20.6%]
Performing permutations : [20.8%]
Performing permutations : [21.0%]
Performing permutations : [21.2%]
Performing permutations : [21.4%]
Performing permutations : [21.6%]
Performing permutations : [21.8%]
Performing permutations : [22.0%]
Performing permutations : [22.2%]
Performing permutations : [22.4%]
Performing permutations : [22.6%]
Performing permutations : [22.8%]
Performing permutations : [23.0%]
Performing permutations : [23.2%]
Performing permutations : [23.4%]
Performing permutations : [23.6%]
Performing permutations : [23.8%]
Performing permutations : [24.0%]
Performing permutations : [24.2%]
Performing permutations : [24.4%]
Performing permutations : [24.6%]
Performing permutations : [24.8%]
Performing permutations : [25.0%]
Performing permutations : [25.2%]
Performing permutations : [25.4%]
Performing permutations : [25.6%]
Performing permutations : [25.8%]
Performing permutations : [26.0%]
Performing permutations : [26.2%]
Performing permutations : [26.4%]
Performing permutations : [26.6%]
Performing permutations : [26.8%]
Performing permutations : [27.0%]
Performing permutations : [27.2%]
Performing permutations : [27.4%]
Performing permutations : [27.6%]
Performing permutations : [27.8%]
Performing permutations : [28.0%]
Performing permutations : [28.2%]
Performing permutations : [28.4%]
Performing permutations : [28.6%]
Performing permutations : [28.8%]
Performing permutations : [29.0%]
Performing permutations : [29.2%]
Performing permutations : [29.4%]
Performing permutations : [29.6%]
Performing permutations : [29.8%]
Performing permutations : [30.0%]
Performing permutations : [30.2%]
Performing permutations : [30.4%]
Performing permutations : [30.6%]
Performing permutations : [30.8%]
Performing permutations : [31.0%]
Performing permutations : [31.2%]
Performing permutations : [31.4%]
Performing permutations : [31.6%]
Performing permutations : [31.8%]
Performing permutations : [32.0%]
Performing permutations : [32.2%]
Performing permutations : [32.4%]
Performing permutations : [32.6%]
Performing permutations : [32.8%]
Performing permutations : [33.0%]
Performing permutations : [33.2%]
Performing permutations : [33.4%]
Performing permutations : [33.6%]
Performing permutations : [33.8%]
Performing permutations : [34.0%]
Performing permutations : [34.2%]
Performing permutations : [34.4%]
Performing permutations : [34.6%]
Performing permutations : [34.8%]
Performing permutations : [35.0%]
Performing permutations : [35.2%]
Performing permutations : [35.4%]
Performing permutations : [35.6%]
Performing permutations : [35.8%]
Performing permutations : [36.0%]
Performing permutations : [36.2%]
Performing permutations : [36.4%]
Performing permutations : [36.6%]
Performing permutations : [36.8%]
Performing permutations : [37.0%]
Performing permutations : [37.2%]
Performing permutations : [37.4%]
Performing permutations : [37.6%]
Performing permutations : [37.8%]
Performing permutations : [38.0%]
Performing permutations : [38.2%]
Performing permutations : [38.4%]
Performing permutations : [38.6%]
Performing permutations : [38.8%]
Performing permutations : [39.0%]
Performing permutations : [39.2%]
Performing permutations : [39.4%]
Performing permutations : [39.6%]
Performing permutations : [39.8%]
Performing permutations : [40.0%]
Performing permutations : [40.2%]
Performing permutations : [40.4%]
Performing permutations : [40.6%]
Performing permutations : [40.8%]
Performing permutations : [41.0%]
Performing permutations : [41.2%]
Performing permutations : [41.4%]
Performing permutations : [41.6%]
Performing permutations : [41.8%]
Performing permutations : [42.0%]
Performing permutations : [42.2%]
Performing permutations : [42.4%]
Performing permutations : [42.6%]
Performing permutations : [42.8%]
Performing permutations : [43.0%]
Performing permutations : [43.2%]
Performing permutations : [43.4%]
Performing permutations : [43.6%]
Performing permutations : [43.8%]
Performing permutations : [44.0%]
Performing permutations : [44.2%]
Performing permutations : [44.4%]
Performing permutations : [44.6%]
Performing permutations : [44.8%]
Performing permutations : [45.0%]
Performing permutations : [45.2%]
Performing permutations : [45.4%]
Performing permutations : [45.6%]
Performing permutations : [45.8%]
Performing permutations : [46.0%]
Performing permutations : [46.2%]
Performing permutations : [46.4%]
Performing permutations : [46.6%]
Performing permutations : [46.8%]
Performing permutations : [47.0%]
Performing permutations : [47.2%]
Performing permutations : [47.4%]
Performing permutations : [47.6%]
Performing permutations : [47.8%]
Performing permutations : [48.0%]
Performing permutations : [48.2%]
Performing permutations : [48.4%]
Performing permutations : [48.6%]
Performing permutations : [48.8%]
Performing permutations : [49.0%]
Performing permutations : [49.2%]
Performing permutations : [49.4%]
Performing permutations : [49.6%]
Performing permutations : [49.8%]
Performing permutations : [50.0%]
Performing permutations : [50.2%]
Performing permutations : [50.4%]
Performing permutations : [50.6%]
Performing permutations : [50.8%]
Performing permutations : [51.0%]
Performing permutations : [51.2%]
Performing permutations : [51.4%]
Performing permutations : [51.6%]
Performing permutations : [51.8%]
Performing permutations : [52.0%]
Performing permutations : [52.2%]
Performing permutations : [52.4%]
Performing permutations : [52.6%]
Performing permutations : [52.8%]
Performing permutations : [53.0%]
Performing permutations : [53.2%]
Performing permutations : [53.4%]
Performing permutations : [53.6%]
Performing permutations : [53.8%]
Performing permutations : [54.0%]
Performing permutations : [54.2%]
Performing permutations : [54.4%]
Performing permutations : [54.6%]
Performing permutations : [54.8%]
Performing permutations : [55.0%]
Performing permutations : [55.2%]
Performing permutations : [55.4%]
Performing permutations : [55.6%]
Performing permutations : [55.8%]
Performing permutations : [56.0%]
Performing permutations : [56.2%]
Performing permutations : [56.4%]
Performing permutations : [56.6%]
Performing permutations : [56.8%]
Performing permutations : [57.0%]
Performing permutations : [57.2%]
Performing permutations : [57.4%]
Performing permutations : [57.6%]
Performing permutations : [57.8%]
Performing permutations : [58.0%]
Performing permutations : [58.2%]
Performing permutations : [58.4%]
Performing permutations : [58.6%]
Performing permutations : [58.8%]
Performing permutations : [59.0%]
Performing permutations : [59.2%]
Performing permutations : [59.4%]
Performing permutations : [59.6%]
Performing permutations : [59.8%]
Performing permutations : [60.0%]
Performing permutations : [60.2%]
Performing permutations : [60.4%]
Performing permutations : [60.6%]
Performing permutations : [60.8%]
Performing permutations : [61.0%]
Performing permutations : [61.2%]
Performing permutations : [61.4%]
Performing permutations : [61.6%]
Performing permutations : [61.8%]
Performing permutations : [62.0%]
Performing permutations : [62.2%]
Performing permutations : [62.4%]
Performing permutations : [62.6%]
Performing permutations : [62.8%]
Performing permutations : [63.0%]
Performing permutations : [63.2%]
Performing permutations : [63.4%]
Performing permutations : [63.6%]
Performing permutations : [63.8%]
Performing permutations : [64.0%]
Performing permutations : [64.2%]
Performing permutations : [64.4%]
Performing permutations : [64.6%]
Performing permutations : [64.8%]
Performing permutations : [65.0%]
Performing permutations : [65.2%]
Performing permutations : [65.4%]
Performing permutations : [65.6%]
Performing permutations : [65.8%]
Performing permutations : [66.0%]
Performing permutations : [66.2%]
Performing permutations : [66.4%]
Performing permutations : [66.6%]
Performing permutations : [66.8%]
Performing permutations : [67.0%]
Performing permutations : [67.2%]
Performing permutations : [67.4%]
Performing permutations : [67.6%]
Performing permutations : [67.8%]
Performing permutations : [68.0%]
Performing permutations : [68.2%]
Performing permutations : [68.4%]
Performing permutations : [68.6%]
Performing permutations : [68.8%]
Performing permutations : [69.0%]
Performing permutations : [69.2%]
Performing permutations : [69.4%]
Performing permutations : [69.6%]
Performing permutations : [69.8%]
Performing permutations : [70.0%]
Performing permutations : [70.2%]
Performing permutations : [70.4%]
Performing permutations : [70.6%]
Performing permutations : [70.8%]
Performing permutations : [71.0%]
Performing permutations : [71.2%]
Performing permutations : [71.4%]
Performing permutations : [71.6%]
Performing permutations : [71.8%]
Performing permutations : [72.0%]
Performing permutations : [72.2%]
Performing permutations : [72.4%]
Performing permutations : [72.6%]
Performing permutations : [72.8%]
Performing permutations : [73.0%]
Performing permutations : [73.2%]
Performing permutations : [73.4%]
Performing permutations : [73.6%]
Performing permutations : [73.8%]
Performing permutations : [74.0%]
Performing permutations : [74.2%]
Performing permutations : [74.4%]
Performing permutations : [74.6%]
Performing permutations : [74.8%]
Performing permutations : [75.0%]
Performing permutations : [75.2%]
Performing permutations : [75.4%]
Performing permutations : [75.6%]
Performing permutations : [75.8%]
Performing permutations : [76.0%]
Performing permutations : [76.2%]
Performing permutations : [76.4%]
Performing permutations : [76.6%]
Performing permutations : [76.8%]
Performing permutations : [77.0%]
Performing permutations : [77.2%]
Performing permutations : [77.4%]
Performing permutations : [77.6%]
Performing permutations : [77.8%]
Performing permutations : [78.0%]
Performing permutations : [78.2%]
Performing permutations : [78.4%]
Performing permutations : [78.6%]
Performing permutations : [78.8%]
Performing permutations : [79.0%]
Performing permutations : [79.2%]
Performing permutations : [79.4%]
Performing permutations : [79.6%]
Performing permutations : [79.8%]
Performing permutations : [80.0%]
Performing permutations : [80.2%]
Performing permutations : [80.4%]
Performing permutations : [80.6%]
Performing permutations : [80.8%]
Performing permutations : [81.0%]
Performing permutations : [81.2%]
Performing permutations : [81.4%]
Performing permutations : [81.6%]
Performing permutations : [81.8%]
Performing permutations : [82.0%]
Performing permutations : [82.2%]
Performing permutations : [82.4%]
Performing permutations : [82.6%]
Performing permutations : [82.8%]
Performing permutations : [83.0%]
Performing permutations : [83.2%]
Performing permutations : [83.4%]
Performing permutations : [83.6%]
Performing permutations : [83.8%]
Performing permutations : [84.0%]
Performing permutations : [84.2%]
Performing permutations : [84.4%]
Performing permutations : [84.6%]
Performing permutations : [84.8%]
Performing permutations : [85.0%]
Performing permutations : [85.2%]
Performing permutations : [85.4%]
Performing permutations : [85.6%]
Performing permutations : [85.8%]
Performing permutations : [86.0%]
Performing permutations : [86.2%]
Performing permutations : [86.4%]
Performing permutations : [86.6%]
Performing permutations : [86.8%]
Performing permutations : [87.0%]
Performing permutations : [87.2%]
Performing permutations : [87.4%]
Performing permutations : [87.6%]
Performing permutations : [87.8%]
Performing permutations : [88.0%]
Performing permutations : [88.2%]
Performing permutations : [88.4%]
Performing permutations : [88.6%]
Performing permutations : [88.8%]
Performing permutations : [89.0%]
Performing permutations : [89.2%]
Performing permutations : [89.4%]
Performing permutations : [89.6%]
Performing permutations : [89.8%]
Performing permutations : [90.0%]
Performing permutations : [90.2%]
Performing permutations : [90.4%]
Performing permutations : [90.6%]
Performing permutations : [90.8%]
Performing permutations : [91.0%]
Performing permutations : [91.2%]
Performing permutations : [91.4%]
Performing permutations : [91.6%]
Performing permutations : [91.8%]
Performing permutations : [92.0%]
Performing permutations : [92.2%]
Performing permutations : [92.4%]
Performing permutations : [92.6%]
Performing permutations : [92.8%]
Performing permutations : [93.0%]
Performing permutations : [93.2%]
Performing permutations : [93.4%]
Performing permutations : [93.6%]
Performing permutations : [93.8%]
Performing permutations : [94.0%]
Performing permutations : [94.2%]
Performing permutations : [94.4%]
Performing permutations : [94.6%]
Performing permutations : [94.8%]
Performing permutations : [95.0%]
Performing permutations : [95.2%]
Performing permutations : [95.4%]
Performing permutations : [95.6%]
Performing permutations : [95.8%]
Performing permutations : [96.0%]
Performing permutations : [96.2%]
Performing permutations : [96.4%]
Performing permutations : [96.6%]
Performing permutations : [96.8%]
Performing permutations : [97.0%]
Performing permutations : [97.2%]
Performing permutations : [97.4%]
Performing permutations : [97.6%]
Performing permutations : [97.8%]
Performing permutations : [98.0%]
Performing permutations : [98.2%]
Performing permutations : [98.4%]
Performing permutations : [98.6%]
Performing permutations : [98.8%]
Performing permutations : [99.0%]
Performing permutations : [99.2%]
Performing permutations : [99.4%]
Performing permutations : [99.6%]
Performing permutations : [99.8%]
p-value: 0.002

Manova for ERP data

# Authors: Alexandre Barachant <alexandre.barachant@gmail.com>
#
# License: BSD (3-clause)

import seaborn as sns

from time import time
from matplotlib import pyplot as plt

import mne
from mne import io
from mne.datasets import sample

from pyriemann.stats import PermutationDistance, PermutationModel
from pyriemann.estimation import XdawnCovariances
from pyriemann.tangentspace import TangentSpace

from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression

print(__doc__)
sns.set_style('whitegrid')
data_path = sample.data_path()

Set parameters and read data

raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
event_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif'
tmin, tmax = -0., 1
event_id = dict(aud_l=1, aud_r=2, vis_l=3, vis_r=4)

# Setup for reading the raw data
raw = io.Raw(raw_fname, preload=True)
raw.filter(2, None, method='iir')  # replace baselining with high-pass
events = mne.read_events(event_fname)

raw.info['bads'] = ['MEG 2443']  # set bad channels
picks = mne.pick_types(raw.info, meg='grad', eeg=False, stim=False, eog=False,
                       exclude='bads')

# Read epochs
epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=False,
                    picks=picks, baseline=None, preload=True, verbose=False)

labels = epochs.events[::5, -1]

# get epochs
epochs_data = epochs.get_data()[::5]

n_perms = 100

Pairwise distance based permutation test

t_init = time()
p_test = PermutationDistance(n_perms, metric='riemann', mode='pairwise',
                             estimator=XdawnCovariances(2))
p, F = p_test.test(epochs_data, labels)
duration = time() - t_init

fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
p_test.plot(nbins=10, axes=axes)
plt.title('Pairwise distance - %.2f sec.' % duration)
print('p-value: %.3f' % p)
sns.despine()
plt.tight_layout()
plt.show()

t-test distance based permutation test

t_init = time()
p_test = PermutationDistance(n_perms, metric='riemann', mode='ttest',
                             estimator=XdawnCovariances(2))
p, F = p_test.test(epochs_data, labels)
duration = time() - t_init

fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
p_test.plot(nbins=10, axes=axes)
plt.title('Pairwise distance - %.2f sec.' % duration)
print('p-value: %.3f' % p)
sns.despine()
plt.tight_layout()
plt.show()

F-test distance based permutation test

t_init = time()
p_test = PermutationDistance(n_perms, metric='riemann', mode='ftest',
                             estimator=XdawnCovariances(2))
p, F = p_test.test(epochs_data, labels)
duration = time() - t_init

fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
p_test.plot(nbins=10, axes=axes)
plt.title('Pairwise distance - %.2f sec.' % duration)
print('p-value: %.3f' % p)
sns.despine()
plt.tight_layout()
plt.show()

Classification based permutation test

clf = make_pipeline(XdawnCovariances(2), TangentSpace('logeuclid'),
                    LogisticRegression())

t_init = time()
p_test = PermutationModel(n_perms, model=clf, cv=3)
p, F = p_test.test(epochs_data, labels)
duration = time() - t_init

fig, axes = plt.subplots(1, 1, figsize=[6, 3], sharey=True)
p_test.plot(nbins=10, axes=axes)
plt.title('Classification - %.2f sec.' % duration)
print('p-value: %.3f' % p)
sns.despine()
plt.tight_layout()
plt.show()

Transfer learning

Using Riemannian geometry for transfer learning and domain adaptation.

Plot the data transformations in the Riemannian Procrustes Analysis

Plot the data transformations in the Riemannian Procrustes Analysis

Motor imagery classification by transfer learning

Motor imagery classification by transfer learning

Comparison of pipelines for transfer learning

Comparison of pipelines for transfer learning

Plot the data transformations in the Riemannian Procrustes Analysis

Use the SpectralEmbedding module to plot in 2D the transformations on the data points from source and target domains when applying the Riemannian Procrustes Analysis 1 to match their statistics.

import numpy as np
import matplotlib.pyplot as plt

from pyriemann.embedding import SpectralEmbedding
from pyriemann.datasets.simulated import make_classification_transfer
from pyriemann.transfer import (
    decode_domains,
    TLCenter,
    TLRotate,
)

Fix seed for reproducible results

seed = 66

# create source and target datasets
n_matrices = 50
X_enc, y_enc = make_classification_transfer(
    n_matrices=n_matrices,
    class_sep=2.0,
    class_disp=0.25,
    domain_sep=2.0,
    theta=np.pi/4,
    random_state=seed
)

# generate dataset
X_org, y, domain = decode_domains(X_enc, y_enc)

# instantiate object for doing spectral embeddings
emb = SpectralEmbedding(n_components=2, metric='riemann')

# create dict to store the embedding after each step of RPA
embedded_points = {}

# embed the original source and target datasets
points = np.concatenate([X_org, np.eye(2)[None, :, :]])  # stack the identity
embedded_points['origin'] = emb.fit_transform(points)

# embed the source and target datasets after recentering
rct = TLCenter(target_domain='target_domain')
X_rct = rct.fit_transform(X_org, y_enc)
points = np.concatenate([X_rct, np.eye(2)[None, :, :]])  # stack the identity
embedded_points['rct'] = emb.fit_transform(points)

# embed the source and target datasets after recentering
rot = TLRotate(target_domain='target_domain', metric='riemann')
X_rot = rot.fit_transform(X_rct, y_enc)

points = np.concatenate([X_org, X_rct, X_rot, np.eye(2)[None, :, :]])
S = emb.fit_transform(points)
S = S - S[-1]
embedded_points['origin'] = S[:4*n_matrices]
embedded_points['rct'] = S[4*n_matrices:8*n_matrices]
embedded_points['rot'] = S[8*n_matrices:-1]

Plot the results, reproducing the Figure 1 of 1.

fig, ax = plt.subplots(figsize=(13.5, 4.4), ncols=3, sharey=True)
plt.subplots_adjust(wspace=0.10)
steps = ['origin', 'rct', 'rot']
titles = ['original', 'after recentering', 'after rotation']
for axi, step, title in zip(ax, steps, titles):
    S_step = embedded_points[step]
    S_source = S_step[domain == 'source_domain']
    y_source = y[domain == 'source_domain']
    S_target = S_step[domain == 'target_domain']
    y_target = y[domain == 'target_domain']
    axi.scatter(
        S_source[y_source == '1'][:, 0],
        S_source[y_source == '1'][:, 1],
        c='C0', s=50, alpha=0.50)
    axi.scatter(
        S_source[y_source == '2'][:, 0],
        S_source[y_source == '2'][:, 1],
        c='C1', s=50, alpha=0.50)
    axi.scatter(
        S_target[y_target == '1'][:, 0],
        S_target[y_target == '1'][:, 1],
        c='C0', s=50, alpha=0.30, marker="^")
    axi.scatter(
        S_target[y_target == '2'][:, 0],
        S_target[y_target == '2'][:, 1],
        c='C1', s=50, alpha=0.30, marker="^")
    axi.scatter(S[-1, 0], S[-1, 1], c='k', s=80, marker="*")
    axi.set_xlim(-0.60, +1.60)
    axi.set_ylim(-1.10, +1.25)
    axi.set_xticks([-0.5, 0.0, 0.5, 1.0, 1.5])
    axi.set_yticks([-1.0, -0.5, 0.0, 0.5, 1.0])
    axi.set_title(title, fontsize=14)
ax[0].scatter([], [], c="C0", label="source - class 0")
ax[0].scatter([], [], c="C1", label="source - class 1")
ax[0].scatter([], [], marker="^", c="C0", label="target - class 0")
ax[0].scatter([], [], marker="^", c="C1", label="target - class 1")
ax[0].legend(loc="upper right")

plt.show()

References

1(1,2)

Riemannian Procrustes analysis: transfer learning for brain-computer interfaces PLC Rodrigues et al, IEEE Transactions on Biomedical Engineering, vol. 66, no. 8, pp. 2390-2401, December, 2018

Motor imagery classification by transfer learning

In this example, we use transfer learning (TL) to classify epochs from a subject using a classifier trained on data from another subject. We consider TL with a pooling strategy: for each target subject of choice, we use the data from several source subjects to train a single classifier using all of their data points pooled together. We compare the results of simply mixing all covariances from all source subjects without any care (dummy) versus transforming the covariances of all subjects so that they are centered around the Identity matrix (recenter) 1. We use data from the Physionet BCI database and compare the classification performance of MDM with each strategy.

import numpy as np
from tqdm import tqdm
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import StratifiedShuffleSplit
import matplotlib.pyplot as plt

from mne import Epochs, pick_types, events_from_annotations
from mne.io import concatenate_raws
from mne.io.edf import read_raw_edf
from mne.datasets import eegbci
from mne import set_log_level

from pyriemann.classification import MDM
from pyriemann.estimation import Covariances
from pyriemann.transfer import (
    encode_domains,
    TLDummy,
    TLCenter,
    TLClassifier,
    TLSplitter,
)

set_log_level(verbose=False)

def get_subject_dataset(subject):

    # Consider epochs that start 1s after cue onset.
    tmin, tmax = 1., 2.
    event_id = dict(hands=2, feet=3)
    runs = [6, 10, 14]  # motor imagery: hands vs feet

    # Download data with MNE
    raw_files = [
        read_raw_edf(f, preload=True) for f in eegbci.load_data(subject, runs)
    ]
    raw = concatenate_raws(raw_files)

    # Select only EEG channels
    picks = pick_types(
        raw.info, meg=False, eeg=True, stim=False, eog=False, exclude='bads')
    # select only nine electrodes: F3, Fz, F4, C3, Cz, C4, P3, Pz, P4
    picks = picks[[31, 33, 35, 8, 10, 12, 48, 50, 52]]

    # Apply band-pass filter
    raw.filter(7., 35., method='iir', picks=picks)

    # Check the events
    events, _ = events_from_annotations(raw, event_id=dict(T1=2, T2=3))

    # Define the epochs
    epochs = Epochs(
        raw,
        events,
        event_id,
        tmin,
        tmax,
        proj=True,
        picks=picks,
        baseline=None,
        preload=True,
        verbose=False)

    # Extract the labels for each event
    labels = epochs.events[:, -1] - 2

    # Compute covariance matrices on scaled data
    covs = Covariances().fit_transform(1e6 * epochs.get_data())

    return covs, labels

We will consider subjects from the Physionet EEG database for which the intra-subject classification has been checked to be > 0.70

subject_list = [1, 2, 4, 7, 8, 15, 20, 29, 34, 35]

# Load the data from subjects
X, y, d = [], [], []
for i, subject_source in enumerate(subject_list):
    X_source_i, y_source_i = get_subject_dataset(subject=subject_source)
    X.append(X_source_i)
    y.append(y_source_i)
    d = d + [f'subject_{subject_source:02}'] * len(X_source_i)
X = np.concatenate(X)
y = np.concatenate(y)
domains = np.array(d)

# Encode the data for transfer learning purposes
X_enc, y_enc = encode_domains(X, y, domains)

# Object for splitting the datasets into training and validation partitions
n_splits = 5  # How many times to split the target domain into train/test
tl_cv = TLSplitter(
    target_domain='',
    cv=StratifiedShuffleSplit(
        n_splits=n_splits, train_size=0.10, random_state=42))

# We consider two types of pipelines for transfer learning
# dct : no transformation of dataset between the domains
# rct : re-center the data points from each domain to the Identity
scores = {meth: [] for meth in ['dummy', 'rct']}

# Base classifier to be wrapped for transfer learning
clf_base = MDM()

# Consider different subjects as target
for subject_target_idx in tqdm(range(len(subject_list))):

    # Change the target domain
    tl_cv.target_domain = f'subject_{subject_list[subject_target_idx]:02}'

    # Create dict for storing results of this particular CV split
    scores_cv = {meth: [] for meth in scores.keys()}

    # Carry out the cross-validation
    for train_idx, test_idx in tl_cv.split(X_enc, y_enc):

        # Split the dataset into training and testing
        X_enc_train, X_enc_test = X_enc[train_idx], X_enc[test_idx]
        y_enc_train, y_enc_test = y_enc[train_idx], y_enc[test_idx]

        # (1) Dummy pipeline: no transfer learning at all.
        # Classifier is trained only with points from the source domain.
        domain_weight_dummy = {}
        for d in np.unique(domains):
            domain_weight_dummy[d] = 1.0
        domain_weight_dummy[tl_cv.target_domain] = 0.0

        pipeline = make_pipeline(
            TLDummy(),
            TLClassifier(
                target_domain=tl_cv.target_domain,
                estimator=clf_base,
                domain_weight=domain_weight_dummy,
            ),
        )

        # Fit and get accuracy score
        pipeline.fit(X_enc_train, y_enc_train)
        scores_cv['dummy'].append(pipeline.score(X_enc_test, y_enc_test))

        # (2) Recentering pipeline: recenter the data from each domain to
        # identity [1]_.
        # Classifier is trained only with points from the source domain.
        domain_weight_rct = {}
        for d in np.unique(domains):
            domain_weight_rct[d] = 1.0
        domain_weight_rct[tl_cv.target_domain] = 0.0

        pipeline = make_pipeline(
            TLCenter(target_domain=tl_cv.target_domain),
            TLClassifier(
                target_domain=tl_cv.target_domain,
                estimator=clf_base,
                domain_weight=domain_weight_rct,
            ),
        )

        pipeline.fit(X_enc_train, y_enc_train)
        scores_cv['rct'].append(pipeline.score(X_enc_test, y_enc_test))

    for meth in scores.keys():
        scores[meth].append(np.mean(scores_cv[meth]))

  0%|          | 0/10 [00:00<?, ?it/s]
 10%|#         | 1/10 [00:03<00:29,  3.25s/it]
 20%|##        | 2/10 [00:06<00:26,  3.27s/it]
 30%|###       | 3/10 [00:09<00:22,  3.29s/it]
 40%|####      | 4/10 [00:12<00:19,  3.22s/it]
 50%|#####     | 5/10 [00:16<00:16,  3.21s/it]
 60%|######    | 6/10 [00:19<00:12,  3.24s/it]
 70%|#######   | 7/10 [00:22<00:09,  3.27s/it]
 80%|########  | 8/10 [00:26<00:06,  3.28s/it]
 90%|######### | 9/10 [00:29<00:03,  3.29s/it]
100%|##########| 10/10 [00:32<00:00,  3.27s/it]
100%|##########| 10/10 [00:32<00:00,  3.26s/it]

Plot results

fig, ax = plt.subplots(figsize=(7, 6))
ax.boxplot(x=[scores[meth] for meth in scores.keys()])
ax.set_ylim(0.45, 1.00)
ax.set_xticklabels(['Dummy', 'Recentering'])
ax.set_ylabel('Classification accuracy')
ax.set_xlabel('Method')
ax.set_title('Transfer learning with data pooled from 10 subjects')

plt.show()

References

1

Transfer Learning: A Riemannian Geometry Framework With Applications to Brain–Computer Interfaces P Zanini et al, IEEE Transactions on Biomedical Engineering, vol. 65, no. 5, pp. 1107-1116, August, 2017

Comparison of pipelines for transfer learning

We compare the classification performance of MDM on five different strategies for transfer learning. These include re-centering the datasets as done in 1, matching the statistical distributions in a semi-supervised way with Riemannian Procrustes Analysis 2, and improving the MDM classifier with a weighting scheme (MDWM) 3. All data points are simulated from a toy model based on the Riemannian Gaussian distribution and the differences in statistics between source and target distributions are determined by a set of parameters that have control over the distance between the centers of each dataset, the angle of rotation between the means of each class, and the differences in dispersion of the data points from each dataset.

from tqdm import tqdm

import numpy as np
import matplotlib.pyplot as plt
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import StratifiedShuffleSplit

from pyriemann.classification import MDM
from pyriemann.datasets.simulated import make_classification_transfer
from pyriemann.transfer import (
    TLSplitter,
    TLDummy,
    TLCenter,
    TLStretch,
    TLRotate,
    TLClassifier,
    MDWM
)

Choose seed for reproducible results

seed = 100

# We consider several types of pipeline for transfer learning
# dummy : no transformation of dataset between the domains
# rct : re-center the data points from each domain to the Identity
# rpa : re-center, stretch and rotate (Riemannian Procrustes Analysis)
# mdwm : transfer learning with minimum distance to weighted mean
# calibration : use only data from target-train partition for the classifier
scores = {meth: [] for meth in ['dummy', 'rct', 'rpa', 'mdwm', 'calibration']}

# Create a dataset with two domains, each with two classes both datasets
# are generated by the same generative procedure with the SPD Gaussian
# and one of them is transformed by a matrix A, i.e. X <- A @ X @ A.T
X_enc, y_enc = make_classification_transfer(
    n_matrices=100,
    class_sep=0.75,
    class_disp=1.0,
    domain_sep=5.0,
    theta=3*np.pi/5,
    random_state=seed,
)

# Object for splitting the datasets into training and validation partitions
# the training set is composed of all data points from the source domain
# plus a partition of the target domain whose size we can control
target_domain = 'target_domain'
n_splits = 5  # how many times to split the target domain into train/test
tl_cv = TLSplitter(
    target_domain=target_domain,
    cv=StratifiedShuffleSplit(n_splits=n_splits, random_state=seed),
)

# Which base classifier to consider
clf_base = MDM()

# Vary the proportion of the target domain for training
target_train_frac_array = np.linspace(0.01, 0.20, 10)
for target_train_frac in tqdm(target_train_frac_array):

    # Change fraction of the target training partition
    tl_cv.cv.train_size = target_train_frac

    # Create dict for storing results of this particular CV split
    scores_cv = {meth: [] for meth in scores.keys()}

    # Carry out the cross-validation
    for train_idx, test_idx in tl_cv.split(X_enc, y_enc):

        # Split the dataset into training and testing
        X_enc_train, X_enc_test = X_enc[train_idx], X_enc[test_idx]
        y_enc_train, y_enc_test = y_enc[train_idx], y_enc[test_idx]

        # (1) Dummy pipeline: no transfer learning at all.
        # Classifier is trained only with samples from the source dataset.
        pipeline = make_pipeline(
            TLDummy(),
            TLClassifier(
                target_domain=target_domain,
                estimator=clf_base,
                domain_weight={'source_domain': 1.0, 'target_domain': 0.0},
            ),
        )

        # Fit and get accuracy score
        pipeline.fit(X_enc_train, y_enc_train)
        scores_cv['dummy'].append(pipeline.score(X_enc_test, y_enc_test))

        # (2) RCT pipeline: recenter data from each domain to identity [1]_.
        # Classifier is trained only with points from the source domain.
        pipeline = make_pipeline(
            TLCenter(target_domain=target_domain),
            TLClassifier(
                target_domain=target_domain,
                estimator=clf_base,
                domain_weight={'source_domain': 1.0, 'target_domain': 0.0},
            ),
        )

        pipeline.fit(X_enc_train, y_enc_train)
        scores_cv['rct'].append(pipeline.score(X_enc_test, y_enc_test))

        # (3) RPA pipeline: recenter, stretch, and rotate [2]_.
        # Classifier is trained with points from source and target.
        pipeline = make_pipeline(
            TLCenter(target_domain=target_domain),
            TLStretch(
                target_domain=target_domain,
                final_dispersion=1,
                centered_data=True,
            ),
            TLRotate(target_domain=target_domain, metric='euclid'),
            TLClassifier(
                target_domain=target_domain,
                estimator=clf_base,
                domain_weight={'source_domain': 0.5, 'target_domain': 0.5},
            ),
        )

        pipeline.fit(X_enc_train, y_enc_train)
        scores_cv['rpa'].append(pipeline.score(X_enc_test, y_enc_test))

        # (4) MDWM pipeline
        domain_tradeoff = 1 - np.exp(-25*target_train_frac)
        pipeline = MDWM(domain_tradeoff=domain_tradeoff,
                        target_domain=target_domain)
        pipeline.fit(X_enc_train, y_enc_train)
        scores_cv['mdwm'].append(pipeline.score(X_enc_test, y_enc_test))

        # (5) Calibration: use only data from target-train partition.
        # Classifier is trained only with points from the target domain.
        pipeline = make_pipeline(
            TLClassifier(
                target_domain=target_domain,
                estimator=clf_base,
                domain_weight={'source_domain': 0.0, 'target_domain': 1.0},
            ),
        )

        pipeline.fit(X_enc_train, y_enc_train)
        scores_cv['calibration'].append(pipeline.score(X_enc_test, y_enc_test))

    # Get the average score of each pipeline
    for meth in scores.keys():
        scores[meth].append(np.mean(scores_cv[meth]))

# Store the results for each method on this particular seed
for meth in scores.keys():
    scores[meth] = np.array(scores[meth])

  0%|          | 0/10 [00:00<?, ?it/s]
 10%|#         | 1/10 [00:01<00:12,  1.34s/it]
 20%|##        | 2/10 [00:05<00:22,  2.85s/it]
 30%|###       | 3/10 [00:10<00:28,  4.13s/it]/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')

 40%|####      | 4/10 [00:19<00:36,  6.03s/it]/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')

 50%|#####     | 5/10 [00:30<00:38,  7.60s/it]/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')

 60%|######    | 6/10 [00:40<00:33,  8.35s/it]/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')

 70%|#######   | 7/10 [00:50<00:27,  9.09s/it]/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')

 80%|########  | 8/10 [01:03<00:20, 10.17s/it]/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')

 90%|######### | 9/10 [01:14<00:10, 10.58s/it]/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')
/home/docs/checkouts/readthedocs.org/user_builds/pyriemann/checkouts/stable/pyriemann/transfer/_rotate.py:132: UserWarning: Convergence not reached.
  warnings.warn('Convergence not reached.')

100%|##########| 10/10 [01:26<00:00, 10.90s/it]
100%|##########| 10/10 [01:26<00:00,  8.62s/it]

Plot the results, reproducing Figure 2 of 2.

fig, ax = plt.subplots(figsize=(6.7, 5.7))
for meth in scores.keys():
    ax.plot(
        target_train_frac_array,
        scores[meth],
        label=meth,
        lw=3.0)
ax.legend(loc='upper right')
ax.set_ylim(0.45, 0.75)
ax.set_yticks([0.5, 0.6, 0.7])
ax.set_xlim(0.00, 0.21)
ax.set_xticks([0.01, 0.05, 0.10, 0.15, 0.20])
ax.set_xticklabels([1, 5, 10, 15, 20])
ax.set_xlabel('Percentage of training partition in target domain')
ax.set_ylabel('Classification accuracy')
ax.set_title('Comparison of transfer learning pipelines')

plt.show()

References

1

Transfer Learning: A Riemannian Geometry Framework With Applications to Brain–Computer Interfaces P Zanini et al, IEEE Transactions on Biomedical Engineering, vol. 65, no. 5, pp. 1107-1116, August, 2017

2(1,2)

Riemannian Procrustes analysis: transfer learning for brain-computer interfaces PLC Rodrigues et al, IEEE Transactions on Biomedical Engineering, vol. 66, no. 8, pp. 2390-2401, December, 2018

3

Transfer Learning for SSVEP-based BCI using Riemannian similarities between users E Kalunga et al, 26th European Signal Processing Conference (EUSIPCO 2018) Sep 2018, Rome, Italy, pp.1685-1689

API reference

SPD Matrices Estimation

Covariances([estimator])	Estimation of covariance matrix.
ERPCovariances([classes, estimator, svd])	Estimate special form covariance matrix for ERP.
XdawnCovariances([nfilter, applyfilters, ...])	Estimate special form covariance matrix for ERP combined with Xdawn.
BlockCovariances(block_size[, estimator])	Estimation of block covariance matrix.
CospCovariances([window, overlap, fmin, ...])	Estimation of cospectral covariance matrix.
Coherences([window, overlap, fmin, fmax, ...])	Estimation of squared coherence matrices.
HankelCovariances([delays, estimator])	Estimation of covariance matrix with time delayed Hankel matrices.
Kernels([metric, n_jobs])	Estimation of kernel matrix between channels of time series.
Shrinkage([shrinkage])	Regularization of SPD matrices by shrinkage.

Embedding

locally_linear_embedding(X, *[, ...])	Perform a Locally Linear Embedding (LLE) of SPD matrices.
barycenter_weights(X, Y, indices[, metric, reg])	Compute Riemannian barycenter weights of X from Y along the first axis.
SpectralEmbedding([n_components, metric, eps])	Spectral embedding of SPD matrices into an Euclidean space.
LocallyLinearEmbedding([n_components, ...])	Locally Linear Embedding (LLE) of SPD matrices.

Classification

MDM([metric, n_jobs])	Classification by Minimum Distance to Mean.
FgMDM([metric, tsupdate, n_jobs])	Classification by Minimum Distance to Mean with geodesic filtering.
TSclassifier([metric, tsupdate, clf])	Classification in the tangent space.
KNearestNeighbor([n_neighbors, metric, n_jobs])	Classification by k-nearest neighbors.
SVC(*[, metric, kernel_fct, Cref, C, ...])	Classification by support-vector machine.
MeanField([power_list, method_label, ...])	Classification by Minimum Distance to Mean Field.

class_distinctiveness(X, y[, exponent, ...])

Measure class distinctiveness between classes of SPD matrices.

Regression

KNearestNeighborRegressor([n_neighbors, metric])	Regression by k-nearest-neighbors.
SVR(*[, metric, kernel_fct, Cref, tol, C, ...])	Regression by support-vector machine.

Clustering

Kmeans([n_clusters, max_iter, metric, ...])	Clustering by k-means with SPD matrices as inputs.
KmeansPerClassTransform([n_clusters])	Clustering by k-means for each class with SPD matrices as inputs.
Potato([metric, threshold, n_iter_max, ...])	Artefact detection with the Riemannian Potato.
PotatoField([n_potatoes, p_threshold, ...])	Artefact detection with the Riemannian Potato Field.

Tangent Space

TangentSpace([metric, tsupdate])	Tangent space project TransformerMixin.
FGDA([metric, tsupdate])	Fisher Geodesic Discriminant analysis.

Spatial Filtering

Xdawn([nfilter, classes, estimator, ...])	Xdawn algorithm.
CSP([nfilter, metric, log])	CSP spatial filtering with covariance matrices as inputs.
SPoC([nfilter, metric, log])	SPoC spatial filtering with covariance matrices as inputs.
BilinearFilter(filters[, log])	Bilinear spatial filter.
AJDC([window, overlap, fmin, fmax, fs, ...])	AJDC algorithm.

Preprocessing

Whitening([metric, dim_red, verbose])

Whitening, and optional unsupervised dimension reduction.

Channel selection

ElectrodeSelection([nelec, metric, n_jobs])	Channel selection based on a Riemannian geometry criterion.
FlatChannelRemover()	Finds and removes flat channels.

Transfer Learning

encode_domains(X, y, domain)	Encode the domains of the matrices in the labels.
decode_domains(X_enc, y_enc)	Decode the domains of the matrices in the labels.
TLSplitter(target_domain, cv)	Class for handling the cross-validation splits of multi-domain data.
TLEstimator(target_domain, estimator[, ...])	Transfer learning wrapper for estimators.
TLClassifier(target_domain, estimator[, ...])	Transfer learning wrapper for classifiers.
TLRegressor(target_domain, estimator[, ...])	Transfer learning wrapper for regressors.
TLDummy()	No transformation on data for transfer learning.
TLCenter(target_domain[, metric])	Recenter data for transfer learning.
TLStretch(target_domain[, final_dispersion, ...])	Stretch data for transfer learning.
TLRotate(target_domain[, weights, metric, ...])	Rotate data for transfer learning.
MDWM(domain_tradeoff, target_domain[, ...])	Classification by Minimum Distance to Weighted Mean.

Stats

PermutationDistance([n_perms, metric, mode, ...])	Permutation test based on distance.
PermutationModel([n_perms, model, cv, ...])	Permutation test using any scikit-learn model for scoring.

Datasets

make_gaussian_blobs([n_matrices, n_dim, ...])	Generate SPD dataset with two classes sampled from Riemannian Gaussian.
make_outliers(n_matrices, mean, sigma[, ...])	Generate a set of outlier points.
make_covariances(n_matrices, n_channels[, ...])	Generate a set of covariances matrices, with the same eigenvectors.
make_masks(n_masks, n_dim0, n_dim1_min[, rs])	Generate a set of masks, defined as semi-orthogonal matrices.
sample_gaussian_spd(n_matrices, mean, sigma)	Sample a Riemannian Gaussian distribution.
generate_random_spd_matrix(n_dim[, ...])	Generate a random SPD matrix.
make_classification_transfer(n_matrices[, ...])	Generate source and target toy datasets for transfer learning examples.

Utils function

Utils functions are low level functions that implement most base components of Riemannian Geometry.

Covariance preprocessing

covariances(X[, estimator])	Estimation of covariance matrix.
covariance_mest(X, m_estimator, *[, init, ...])	Robust M-estimators.
covariance_sch(X)	Schaefer-Strimmer shrunk covariance estimator.
covariances_EP(X, P[, estimator])	Special form covariance matrix, concatenating a prototype P.
covariances_X(X[, estimator, alpha])	Special form covariance matrix, embedding input X.
block_covariances(X, blocks[, estimator])	Compute block diagonal covariance.
cross_spectrum(X[, window, overlap, fmin, ...])	Compute the complex cross-spectral matrices of a real signal X.
cospectrum(X[, window, overlap, fmin, fmax, fs])	Compute co-spectral matrices, the real part of cross-spectra.
coherence(X[, window, overlap, fmin, fmax, ...])	Compute squared coherence.
normalize(X, norm)	Normalize a set of square matrices, using corr, trace or determinant.
get_nondiag_weight(X)	Compute non-diagonality weights of a set of square matrices.

Distances

distance(A, B[, metric])	Distance between SPD matrices according to a metric.
distance_euclid(A, B)	Euclidean distance between SPD matrices.
distance_harmonic(A, B)	Harmonic distance between SPD matrices.
distance_kullback(A, B)	Kullback-Leibler divergence between SPD matrices.
distance_kullback_sym(A, B)	Symmetrized Kullback-Leibler divergence between SPD matrices.
distance_logdet(A, B)	Log-det distance between SPD matrices.
distance_logeuclid(A, B)	Log-Euclidean distance between SPD matrices.
distance_riemann(A, B)	Affine-invariant Riemannian distance between SPD matrices.
distance_wasserstein(A, B)	Wasserstein distance between SPD matrices.
distance_mahalanobis(X, cov[, mean])	Mahalanobis distance between vectors and a Gaussian distribution.

Means

mean_covariance(covmats[, metric, sample_weight])	Mean of SPD matrices according to a metric.
mean_ale(covmats[, tol, maxiter, sample_weight])	AJD-based log-Euclidean (ALE) mean of SPD matrices.
mean_alm(covmats[, tol, maxiter, sample_weight])	Ando-Li-Mathias (ALM) mean of SPD matrices.
mean_euclid(covmats[, sample_weight])	Mean of matrices according to the Euclidean metric.
mean_harmonic(covmats[, sample_weight])	Harmonic mean of SPD matrices.
mean_identity(covmats[, sample_weight])	Identity matrix corresponding to the matrices dimension.
mean_kullback_sym(covmats[, sample_weight])	Mean of SPD matrices according to Kullback-Leibler divergence.
mean_logdet(covmats[, tol, maxiter, init, ...])	Mean of SPD matrices according to the log-det metric.
mean_logeuclid(covmats[, sample_weight])	Mean of SPD matrices according to the log-Euclidean metric.
mean_power(covmats, p, *[, sample_weight, ...])	Power mean of SPD matrices.
mean_riemann(covmats[, tol, maxiter, init, ...])	Mean of SPD matrices according to the Riemannian metric.
mean_wasserstein(covmats[, tol, maxiter, ...])	Mean of SPD matrices according to the Wasserstein metric.
maskedmean_riemann(covmats, masks[, tol, ...])	Masked Riemannian mean of SPD matrices.
nanmean_riemann(covmats[, tol, maxiter, ...])	Riemannian NaN-mean of SPD matrices.

Medians

median_euclid(X, *[, tol, maxiter, init, ...])	Euclidean geometric median of matrices.
median_riemann(X, *[, tol, maxiter, init, ...])	Affine-invariant Riemannian geometric median of SPD matrices.

Geodesics

geodesic(A, B, alpha[, metric])	Geodesic between SPD matrices according to a metric.
geodesic_euclid(A, B[, alpha])	Euclidean geodesic between SPD matrices.
geodesic_logeuclid(A, B[, alpha])	Log-Euclidean geodesic between SPD matrices.
geodesic_riemann(A, B[, alpha])	Affine-invariant Riemannian geodesic between SPD matrices.

Kernels

kernel(X[, Y, Cref, metric, reg])	Kernel matrix between SPD matrices according to a specified metric.
kernel_euclid(X[, Y, reg])	Euclidean kernel between two sets of SPD matrices.
kernel_logeuclid(X[, Y, reg])	Log-Euclidean kernel between two sets of SPD matrices.
kernel_riemann(X[, Y, Cref, reg])	Affine-invariant Riemannian kernel between two sets of SPD matrices.

Tangent Space

exp_map_euclid(X, Cref)	Project matrices back to SPD manifold by Euclidean exponential map.
exp_map_logeuclid(X, Cref)	Project matrices back to SPD manifold by Log-Euclidean exponential map.
exp_map_riemann(X, Cref[, Cm12])	Project matrices back to SPD manifold by Riemannian exponential map.
log_map_euclid(X, Cref)	Project SPD matrices in tangent space by Euclidean logarithmic map.
log_map_logeuclid(X, Cref)	Project SPD matrices in tangent space by Log-Euclidean logarithmic map.
log_map_riemann(X, Cref[, C12])	Project SPD matrices in tangent space by Riemannian logarithmic map.
upper(X)	Return the weighted upper triangular part of symmetric matrices.
unupper(T)	Inverse upper function.
tangent_space(X, Cref, *[, metric])	Transform SPD matrices into tangent vectors.
untangent_space(T, Cref, *[, metric])	Transform tangent vectors back to SPD matrices.

Base

sqrtm(C)	Square root of SPD matrices.
invsqrtm(C)	Inverse square root of SPD matrices.
expm(C)	Exponential of SPD matrices.
logm(C)	Logarithm of SPD matrices.
powm(C, alpha)	Power of SPD matrices.
nearest_sym_pos_def(X[, reg])	Find the nearest SPD matrices.

Aproximate Joint Diagonalization

ajd_pham(X, *[, init, eps, n_iter_max, ...])	Approximate joint diagonalization based on Pham's algorithm.
rjd(X, *[, init, eps, n_iter_max])	Approximate joint diagonalization based on Jacobi angles.
uwedge(X, *[, init, eps, n_iter_max])	Approximate joint diagonalization based on UWEDGE.

Matrix Tests

is_square(X)	Check if matrices are square.
is_sym(X)	Check if all matrices are symmetric.
is_skew_sym(X)	Check if all matrices are skew-symmetric.
is_real(X)	Check if all complex matrices are strictly real.
is_hermitian(X)	Check if all matrices are Hermitian.
is_pos_def(X[, fast_mode])	Check if all matrices are positive definite.
is_pos_semi_def(X)	Check if all matrices are positive semi-definite.
is_sym_pos_def(X)	Check if all matrices are symmetric positive-definite.
is_sym_pos_semi_def(X)	Check if all matrices are symmetric positive semi-definite.

Visualization

plot_confusion_matrix(*args, **kwargs)	Warning DEPRECATED: plot_confusion_matrix is deprecated and will be remove in 0.4.0; please use sklearn confusion_matrix and ConfusionMatrixDisplay; see examples/ERP/plot_classify_EEG_tangentspace.py
plot_embedding(X[, y, metric, title, ...])	Plot 2D embedding of SPD matrices.
plot_cospectra(cosp, freqs, *[, ylabels, title])	Plot cospectral matrices.
plot_waveforms(X, display, *[, times, ...])	Display repetitions of a multichannel waveform.