Convolutional neural network regression model on fake data.#

This example shows how to create a CNN regressor from a CNN classifier by removing softmax function from the classifier’s output layer and how to train it on a fake regression dataset.

# Authors: Lukas Gemein <l.gemein@gmail.com>
#          Sara Sedlar <sara.sedlar@gmail.com>
# License: BSD-3

Fake regression data#

Function for generation of the fake regression dataset generates n_fake_recs recordings, each containing sinusoidal signals with Gaussian noise. Each fake recording signal has n_fake_chs channels, it lasts fake_duration [s] and it is sampled with fake_sfreq [Hz]. The recordings are split into train, validation and testing sessions.

import numpy as np
import pandas as pd

from braindecode.datasets import BaseConcatDataset, RawDataset
from braindecode.util import create_mne_dummy_raw

Function for generating fake regression data

def fake_regression_dataset(
    n_fake_recs,
    n_fake_chs,
    fake_sfreq,
    fake_duration,
    n_fake_targets,
    fake_data_split=[0.6, 0.2, 0.2],
):
    """Generate a fake regression dataset.

    Parameters
    ----------
    n_fake_recs : int
        Number of fake recordings.
    n_fake_chs : int
        Number of fake EEG channels.
    fake_sfreq : float
        Fake sampling frequency in Hz.
    fake_duration : float
        Fake recording duration in seconds.
    n_fake_targets : int
        Number of targets.
    fake_data_split : list
        List of train/valid/test subset fractions.

    Returns
    -------
    dataset : BaseConcatDataset object
        The generated dataset object.

    """
    datasets = []
    for i in range(n_fake_recs):
        if i < int(fake_data_split[0] * n_fake_recs):
            target_subset = "train"
        elif i < int((1 - fake_data_split[2]) * n_fake_recs):
            target_subset = "valid"
        else:
            target_subset = "test"
        raw, _ = create_mne_dummy_raw(
            n_channels=n_fake_chs, n_times=fake_duration * fake_sfreq, sfreq=fake_sfreq
        )

        target = np.random.randint(0, 10, n_fake_targets)
        for j in range(n_fake_targets):
            x = np.sin(2 * np.pi * target[j] * raw.times)
            raw._data += np.expand_dims(x, axis=0)

        if n_fake_targets == 1:
            target = target[0]
        fake_description = pd.Series(
            data=[target, target_subset], index=["target", "session"]
        )
        datasets.append(RawDataset(raw, fake_description, target_name="target"))

    return BaseConcatDataset(datasets)

Generating fake regression dataset#

n_fake_rec = 20
n_fake_chans = 21
fake_sfreq = 100
fake_duration = 30
n_fake_targets = 1
dataset = fake_regression_dataset(
    n_fake_recs=n_fake_rec,
    n_fake_chs=n_fake_chans,
    fake_sfreq=fake_sfreq,
    fake_duration=fake_duration,
    n_fake_targets=n_fake_targets,
)

Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.
Creating RawArray with float64 data, n_channels=21, n_times=3000
    Range : 0 ... 2999 =      0.000 ...    29.990 secs
Ready.

Defining a CNN regression model#

Choosing and defining a CNN classifier, ShallowFBCSPNet or Deep4Net, introduced in [1]. To convert a classifier to a regressor, softmax function is removed from its output layer.

import torch

from braindecode.models import Deep4Net, ShallowFBCSPNet
from braindecode.util import set_random_seeds

# Choosing a CNN model
model_name = "shallow"  # 'shallow' or 'deep'

# Defining a CNN model
if model_name in ["shallow", "Shallow", "ShallowConvNet"]:
    model = ShallowFBCSPNet(
        n_chans=n_fake_chans,
        n_outputs=n_fake_targets,
        n_times=fake_sfreq * fake_duration,
        n_filters_time=40,
        n_filters_spat=40,
        final_conv_length=35,
    )
elif model_name in ["deep", "Deep", "DeepConvNet"]:
    model = Deep4Net(
        n_chans=n_fake_chans,
        n_outputs=n_fake_targets,
        n_times=fake_sfreq * fake_duration,
        n_filters_time=25,
        n_filters_spat=25,
        stride_before_pool=True,
        n_filters_2=n_fake_chans * 2,
        n_filters_3=n_fake_chans * 4,
        n_filters_4=n_fake_chans * 8,
        final_conv_length=1,
    )
else:
    raise ValueError(f"{model_name} unknown")

Choosing between GPU and CPU processors#

By default, model’s training and evaluation take place at GPU if it exists, otherwise on CPU.

cuda = torch.cuda.is_available()
device = "cuda" if cuda else "cpu"
if cuda:
    torch.backends.cudnn.benchmark = True

# Setting a random seed
seed = 20200220
set_random_seeds(seed=seed, cuda=cuda)
if cuda:
    model.cuda()

Data windowing#

Windowing data with a sliding window into the epochs of the size window_size_samples.

from braindecode.preprocessing import create_fixed_length_windows

window_size_samples = fake_sfreq * fake_duration // 3
model.to_dense_prediction_model()

n_preds_per_input = model.get_output_shape()[2]
windows_dataset = create_fixed_length_windows(
    dataset,
    start_offset_samples=0,
    stop_offset_samples=0,
    window_size_samples=window_size_samples,
    window_stride_samples=n_preds_per_input,
    drop_last_window=False,
    preload=True,
)

# Splitting windowed data into train, valid and test subsets.
splits = windows_dataset.split("session")
train_set = splits["train"]
valid_set = splits["valid"]
test_set = splits["test"]

/home/runner/work/braindecode/braindecode/examples/model_building/plot_regression.py:175: DeprecationWarning: `drop_last_window` is deprecated and will be removed in version 2.0. Use `on_last_window='drop'` if True or `on_last_window='overlap'` if False. See https://github.com/braindecode/braindecode/pull/1058 for feedback.
  windows_dataset = create_fixed_length_windows(
/home/runner/work/braindecode/braindecode/braindecode/preprocessing/windowers.py:1388: UserWarning: Meaning of `trial_stop_offset_samples`=0 has changed, use `None` to indicate end of trial/recording. Using `None`.
  warnings.warn(

Model training#

Model is trained by minimizing MSE loss between ground truth and estimated value averaged over a period of time using AdamW optimizer [2], [3]. Learning rate is managed by CosineAnnealingLR learning rate scheduler.

from skorch.callbacks import LRScheduler
from skorch.helper import predefined_split

from braindecode import EEGRegressor
from braindecode.training.losses import CroppedLoss

batch_size = 4
n_epochs = 3
optimizer_lr = 0.001
optimizer_weight_decay = 0.0
regressor = EEGRegressor(
    model,
    cropped=True,
    criterion=CroppedLoss,
    criterion__loss_function=torch.nn.functional.mse_loss,
    optimizer=torch.optim.AdamW,
    optimizer__lr=optimizer_lr,
    optimizer__weight_decay=optimizer_weight_decay,
    train_split=predefined_split(valid_set),
    iterator_train__shuffle=True,
    batch_size=batch_size,
    callbacks=[
        "neg_root_mean_squared_error",
        ("lr_scheduler", LRScheduler("CosineAnnealingLR", T_max=n_epochs - 1)),
    ],
    device=device,
)
regressor.fit(train_set, y=None, epochs=n_epochs)

  epoch    train_loss    train_neg_root_mean_squared_error    valid_loss    valid_neg_root_mean_squared_error      lr     dur
-------  ------------  -----------------------------------  ------------  -----------------------------------  ------  ------
      1       17.5662                              -5.6095       27.6535                              -5.2585  0.0010  0.3091
      2       10.3976                              -5.7347       30.9822                              -5.5660  0.0005  0.2787
      3        7.2923                              -4.2520       17.2477                              -4.1529  0.0000  0.2869

<class 'braindecode.regressor.EEGRegressor'>[initialized](
  module_==================================================================================================================================================
  Layer (type (var_name):depth-idx)             Input Shape               Output Shape              Param #                   Kernel Shape
  =================================================================================================================================================
  ShallowFBCSPNet (ShallowFBCSPNet)             [1, 21, 3000]             [1, 1, 2392]              --                        --
  ├─Ensure4d (ensuredims): 1-1                  [1, 21, 3000]             [1, 21, 3000, 1]          --                        --
  ├─Rearrange (dimshuffle): 1-2                 [1, 21, 3000, 1]          [1, 1, 3000, 21]          --                        --
  ├─CombinedConv (conv_time_spat): 1-3          [1, 1, 3000, 21]          [1, 40, 2976, 1]          34,640                    --
  ├─BatchNorm2d (bnorm): 1-4                    [1, 40, 2976, 1]          [1, 40, 2976, 1]          80                        --
  ├─Square (conv_nonlin_exp): 1-5               [1, 40, 2976, 1]          [1, 40, 2976, 1]          --                        --
  ├─AvgPool2d (pool): 1-6                       [1, 40, 2976, 1]          [1, 40, 2902, 1]          --                        [75, 1]
  ├─SafeLog (pool_nonlin_exp): 1-7              [1, 40, 2902, 1]          [1, 40, 2902, 1]          --                        --
  ├─Dropout (drop): 1-8                         [1, 40, 2902, 1]          [1, 40, 2902, 1]          --                        --
  ├─Sequential (final_layer): 1-9               [1, 40, 2902, 1]          [1, 1, 2392]              --                        --
  │    └─Conv2d (conv_classifier): 2-1          [1, 40, 2902, 1]          [1, 1, 2392, 1]           1,401                     [35, 1]
  │    └─SqueezeFinalOutput (squeeze): 2-2      [1, 1, 2392, 1]           [1, 1, 2392]              --                        --
  │    │    └─Rearrange (squeeze): 3-1          [1, 1, 2392, 1]           [1, 1, 2392]              --                        --
  =================================================================================================================================================
  Total params: 36,121
  Trainable params: 36,121
  Non-trainable params: 0
  Total mult-adds (Units.MEGABYTES): 3.35
  =================================================================================================================================================
  Input size (MB): 0.25
  Forward/backward pass size (MB): 0.97
  Params size (MB): 0.01
  Estimated Total Size (MB): 1.23
  =================================================================================================================================================,
)

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

EEGRegressor

iFitted

Parameters

	module	ShallowFBCSPN...') ) ) )
	cropped	True
	callbacks	['neg_root_mean_squared_error', ('lr_scheduler', ...)]
	criterion	<class 'brain....CroppedLoss'>
	optimizer	<class 'torch....adamw.AdamW'>
	lr	0.01
	max_epochs	10
	batch_size	4
	iterator_train	<class 'torch...r.DataLoader'>
	iterator_valid	<class 'torch...r.DataLoader'>
	dataset	<class 'skorc...aset.Dataset'>
	train_split	functools.par... 5: 2, 6: 2}))
	predict_nonlinearity	'auto'
	warm_start	False
	verbose	1
	device	'cpu'
	compile	False
	use_caching	'auto'
	torch_load_kwargs	None
	_params_to_validate	{'criterion__loss_function', 'iterator_train__drop_last', 'iterator_train__shuffle', 'optimizer__lr', 'optimizer__weight_decay'}
	criterion__loss_function	<function mse...x7f9734a40ea0>
	optimizer__lr	0.001
	optimizer__weight_decay	0.0
	callbacks__epoch_timer	<skorch.callb...x7f9708527350>
	callbacks__train_loss	<skorch.callb...x7f970858c3b0>
	callbacks__train_loss__scoring	<function tra...x7f9733039a80>
	callbacks__train_loss__lower_is_better	True
	callbacks__train_loss__on_train	True
	callbacks__train_loss__name	'train_loss'
	callbacks__train_loss__target_extractor	<function noo...x7f97330398a0>
	callbacks__train_loss__use_caching	True
	callbacks__valid_loss	<skorch.callb...x7f9708532630>
	callbacks__valid_loss__scoring	<function val...x7f9733039b20>
	callbacks__valid_loss__lower_is_better	True
	callbacks__valid_loss__on_train	False
	callbacks__valid_loss__name	'valid_loss'
	callbacks__valid_loss__target_extractor	<function noo...x7f97330398a0>
	callbacks__valid_loss__use_caching	True
	callbacks__train_neg_root_mean_squared_error	<braindecode....x7f972558c080>
	callbacks__train_neg_root_mean_squared_error__scoring	'neg_root_mean_squared_error'
	callbacks__train_neg_root_mean_squared_error__lower_is_better	False
	callbacks__train_neg_root_mean_squared_error__on_train	True
	callbacks__train_neg_root_mean_squared_error__name	'train_neg_root_mean_squared_error'
	callbacks__train_neg_root_mean_squared_error__target_extractor	<function to_...x7f9733038e00>
	callbacks__train_neg_root_mean_squared_error__use_caching	True
	callbacks__train_neg_root_mean_squared_error__crops_to_trials_computed	False
	callbacks__valid_neg_root_mean_squared_error	<braindecode....x7f972d6cd580>
	callbacks__valid_neg_root_mean_squared_error__scoring	'neg_root_mean_squared_error'
	callbacks__valid_neg_root_mean_squared_error__lower_is_better	False
	callbacks__valid_neg_root_mean_squared_error__on_train	False
	callbacks__valid_neg_root_mean_squared_error__name	'valid_neg_root_mean_squared_error'
	callbacks__valid_neg_root_mean_squared_error__target_extractor	<function to_...x7f9733038e00>
	callbacks__valid_neg_root_mean_squared_error__use_caching	True
	callbacks__valid_neg_root_mean_squared_error__crops_to_trials_computed	False
	callbacks__lr_scheduler	<skorch.callb...x7f972558d850>
	callbacks__lr_scheduler__policy	'CosineAnnealingLR'
	callbacks__lr_scheduler__monitor	'train_loss'
	callbacks__lr_scheduler__event_name	'event_lr'
	callbacks__lr_scheduler__step_every	'epoch'
	callbacks__lr_scheduler__T_max	2
	callbacks__print_log	<skorch.callb...x7f9725ea89e0>
	callbacks__print_log__keys_ignored	None
	callbacks__print_log__sink	<built-in function print>
	callbacks__print_log__tablefmt	'simple'
	callbacks__print_log__floatfmt	'.4f'
	callbacks__print_log__stralign	'right'
	iterator_train__shuffle	True
	iterator_train__drop_last	True
	aggregate_predictions	True

Fitted attributes

Name	Type	Value
callbacks_	list	[('ep...er', <skorch.callb...x7f9725560800>), ('tr...ss', <skorch.callb...x7f972d6cda00>), ('va...ss', <skorch.callb...x7f972d6cca40>), ('tr...or', <braindecode....x7f972558c080>), ...]
criterion_	CroppedLoss	CroppedLoss()
cuda_dependent_attributes_	list	['module_', 'cr...n_', 'op...r_']
history_	History	[{'batches': ...ent_lr': 0.0}]
init_context_	NoneType	None
initialized_	bool	True
module_	ShallowFBCSPNet	ShallowFBCSPN...') ) ) )
optimizer_	AdamW	AdamW ( Param...t_decay: 0.0 )
prefixes_	list	['it...in', 'it...id', 'ca...ks', 'dataset', ...]
signal_args_set_	bool	True
virtual_params_	dict	{'lr': functools.par...e='optimizer'), 'op..._': functools.par...e='optimizer'), 'op..._': functools.par...e='optimizer')}

Model evaluation#

Plotting training and validation losses and negative root mean square error

import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(10, 5))
axes[0].set_title("Train and valid losses")
axes[0].plot(regressor.history[:, "train_loss"])
axes[0].plot(regressor.history[:, "valid_loss"])
axes[0].set_xlabel("Epochs")
axes[0].set_ylabel("Cropped MSE loss")
axes[0].legend(["Train", "Valid"])

axes[1].set_title("Train and valid errors")
axes[1].plot(regressor.history[:, "train_neg_root_mean_squared_error"])
axes[1].plot(regressor.history[:, "valid_neg_root_mean_squared_error"])
axes[1].set_xlabel("Epochs")
axes[1].set_ylabel("Negative RMSE")
axes[1].legend(["Train", "Valid"])

Train and valid losses, Train and valid errors

<matplotlib.legend.Legend object at 0x7f9703087a10>

Model testing#

Plotting a scatter plot of estimated versus target values and corresponding trend line.

fig, axes = plt.subplots(1, 1, figsize=(5, 5))
y_estim = np.ravel(regressor.predict(test_set))
y_gt = test_set.get_metadata()["target"].to_numpy()

_ = axes.scatter(y_gt, y_estim)
_ = axes.set_ylabel("Estimated targets.")
_ = axes.set_xlabel("Ground truth targets.")

z = np.polyfit(y_gt, y_estim, 1)
p = np.poly1d(z)
plt.plot(y_gt, p(y_gt), "r--")
plt.show()

References#

Total running time of the script: (0 minutes 2.313 seconds)

Gallery generated by Sphinx-Gallery