braindecode 1.8.1.dev168760068__tar.gz → 1.8.1.dev168889947__tar.gz

{braindecode-1.8.1.dev168760068 → braindecode-1.8.1.dev168889947}/NOTICE.txt

@@ -49,6 +49,7 @@ The following components are licensed under the MIT License:
 - `braindecode/modules/popt_modules.py`
 - `braindecode/models/brainomni.py`
 - `braindecode/modules/quantization.py`
+- `braindecode/modules/linear_attention.py`
 - `braindecode/models/seizure_transformer.py`
 - `docs/_static/model/seizure_transformer_arch.png`
 - `braindecode/models/tmsanet.py`
@@ -57,6 +58,8 @@ The `brainomni.py` file is a derivative of `OpenTSLab/BrainOmni` (MIT), whose
 SEANet codec derives from Meta's `facebookresearch/encodec` (MIT). The
 `quantization.py` module holds the residual vector quantization derived from
 `lucidrains/vector-quantize-pytorch` (MIT) and the BrainOmni port.
+The `linear_attention.py` module is the part of
+`lucidrains/linear-attention-transformer` (MIT) that BIOT and TFMTokenizer run.
 
 ### Apache-2.0 Licensed Files
 

{braindecode-1.8.1.dev168760068/braindecode.egg-info → braindecode-1.8.1.dev168889947}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev168760068
+Version: 1.8.1.dev168889947
 Summary: Deep learning software to decode EEG, ECG or MEG signals
 Author-email: Robin Tibor Schirrmeister <robintibor@gmail.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Alexandre Gramfort <agramfort@meta.com>
 Maintainer-email: Alexandre Gramfort <agramfort@meta.com>, Bruno Aristimunha Pinto <b.aristimunha@gmail.com>, Robin Tibor Schirrmeister <robintibor@gmail.com>

{braindecode-1.8.1.dev168760068 → braindecode-1.8.1.dev168889947}/braindecode/augmentation/functional.py

@@ -3,6 +3,7 @@
 #          Gustavo Rodrigues <gustavenrique01@gmail.com>
 #          Bruna Lopes <brunajaflopes@gmail.com>
 #          Sarthak Tayal <sarthaktayal2@gmail.com>
+#          Anton Soloviev <anton@praviel.com>
 #
 # License: BSD (3-clause)
 
@@ -1093,7 +1094,8 @@ def segmentation_reconstruction(
     y : torch.Tensor
         EEG labels for the example or batch.
     n_segments : int
-        Number of segments to use in the batch.
+        Number of segments to use in the batch. Any remaining samples are
+        included in the last segment.
     data_classes : list[tuple[int, torch.Tensor]]
         List of tuples. Each tuple contains the class index and the corresponding EEG data.
     rand_indices : array-like
@@ -1133,6 +1135,8 @@ def segmentation_reconstruction(
         for idx_segment in range(n_segments):
             start = idx_segment * segment_size
             end = (idx_segment + 1) * segment_size
+            if idx_segment == n_segments - 1:
+                end = window_size
 
             # Perform the data augmentation
             X_aug[np.arange(n_trials), :, start:end] = X_class[

{braindecode-1.8.1.dev168760068 → braindecode-1.8.1.dev168889947}/braindecode/functional/__init__.py

@@ -3,11 +3,13 @@ from .functions import (
     daubechies_filters,
     drop_path,
     dwt_max_level,
+    fft_conv1d,
     hilbert_freq,
     identity,
     iou_1d,
     pairwise_iou_1d,
     plv_time,
+    prefer_fft_conv,
     rotate_pairs,
     safe_log,
     sinusoidal_positional_encoding,
@@ -22,11 +24,13 @@ __all__ = [
     "daubechies_filters",
     "drop_path",
     "dwt_max_level",
+    "fft_conv1d",
     "hilbert_freq",
     "identity",
     "iou_1d",
     "pairwise_iou_1d",
     "plv_time",
+    "prefer_fft_conv",
     "rotate_pairs",
     "safe_log",
     "sinusoidal_positional_encoding",

{braindecode-1.8.1.dev168760068 → braindecode-1.8.1.dev168889947}/braindecode/functional/functions.py

@@ -7,6 +7,7 @@
 from __future__ import annotations
 
 import math
+from typing import Optional
 
 import numpy as np
 import torch
@@ -54,6 +55,91 @@ def spectral_input(x: torch.Tensor) -> torch.Tensor:
     return x.to(torch.promote_types(x.dtype, torch.float32))
 
 
+def fft_conv1d(
+    x: torch.Tensor, weight: torch.Tensor, bias: Optional[torch.Tensor] = None
+) -> torch.Tensor:
+    """``F.conv1d(x, weight, bias, padding="same")`` computed with FFTs.
+
+    Equal to the direct convolution up to float rounding: the FFT is long
+    enough for a linear (not circular) convolution. Its cost barely grows with
+    the kernel size, so it is faster than the direct one for long kernels on
+    CPU (see :func:`prefer_fft_conv`). float16/bfloat16 inputs are computed in
+    float32 (:func:`spectral_input`) and cast back.
+
+    Parameters
+    ----------
+    x : torch.Tensor
+        Input of shape ``(batch, in_channels, n_times)``.
+    weight : torch.Tensor
+        Kernels of shape ``(out_channels, in_channels, kernel_size)``.
+    bias : torch.Tensor | None
+        Bias of shape ``(out_channels,)``.
+
+    Returns
+    -------
+    torch.Tensor
+        Output of shape ``(batch, out_channels, n_times)``, dtype and device of
+        ``x``. For an even ``kernel_size`` it is aligned like torch's
+        ``padding="same"`` (the extra zero padded on the right).
+    """
+    n_times, kernel_size = x.shape[-1], weight.shape[-1]
+    # >= n_times + kernel_size - 1 (no circular wrap-around), even and
+    # 5-smooth: the fast cases of a real FFT
+    n_fft = 2 * _next_fast_len((n_times + kernel_size) // 2)
+    xs = spectral_input(x)
+    # conv1d is a cross-correlation: a convolution with the flipped kernel
+    x_f = torch.fft.rfft(xs, n=n_fft).permute(2, 0, 1)  # (freq, batch, in)
+    w_f = torch.fft.rfft(weight.to(xs).flip(-1), n=n_fft).permute(2, 1, 0)
+    # Per frequency (batch, in) @ (in, out) in complex numbers, as one real
+    # matmul (a complex one is slower on CPU): [Re x; Im x] @ [Re w, Im w]
+    # (columns interleaved) holds the four real products.
+    p = torch.cat([x_f.real, x_f.imag], 1) @ torch.view_as_real(w_f).flatten(2)
+    p = p.unflatten(1, [2, x.shape[0]]).unflatten(3, [-1, 2])  # x re/im, w re/im
+    y_f = torch.complex(
+        p[:, 0, :, :, 0] - p[:, 1, :, :, 1], p[:, 0, :, :, 1] + p[:, 1, :, :, 0]
+    )
+    y = torch.fft.irfft(y_f.permute(1, 2, 0), n=n_fft)
+    # "same" output t is sample t + kernel_size // 2 of the full convolution
+    y = y[..., kernel_size // 2 : kernel_size // 2 + n_times]
+    if bias is not None:
+        y = y + bias.to(y).unsqueeze(-1)
+    return y.to(x)
+
+
+def prefer_fft_conv(x: torch.Tensor, kernel_size: int) -> bool:
+    """Whether :func:`fft_conv1d` is expected to beat a direct convolution.
+
+    Rule measured for :class:`~braindecode.models.EEGInceptionMI` (48 to 240
+    channels, 128-500 Hz, 2 CPU threads, oneDNN on and off): on CPU the FFT
+    wins for float16/bfloat16 inputs (no fast half-precision CPU convolution)
+    and from ``batch_size * kernel_size >= 600``. GPUs and HPUs (no complex
+    dtype) keep the direct convolution.
+
+    Parameters
+    ----------
+    x : torch.Tensor
+        Input of the convolution, ``(batch, in_channels, n_times)``.
+    kernel_size : int
+        Kernel length in samples.
+    """
+    return x.device.type == "cpu" and (
+        x.element_size() == 2 or x.shape[0] * kernel_size >= 600
+    )
+
+
+def _next_fast_len(n: int) -> int:
+    """Smallest ``2^a 3^b 5^c >= n`` (scipy's ``next_fast_len(n, real=True)``)."""
+    n -= 1
+    m = 0
+    while m != 1:
+        n += 1
+        m = n
+        for p in [2, 3, 5]:
+            while m % p == 0:
+                m = m // p
+    return n
+
+
 def drop_path(
     x, drop_prob: float = 0.0, training: bool = False, scale_by_keep: bool = True
 ):
@@ -281,18 +367,24 @@ def plv_time(
     )
     # Normalize the analytic signal to obtain unit vectors (phasors).
     unit_phasor = analytic_signal / amplitude.unsqueeze(-1)
+    # The real/imaginary slices are strided (step 2): matmul copied each of
+    # them for every product, per batch matrix. Copy them once.
+    real = unit_phasor[..., 0].contiguous()
+    imag = unit_phasor[..., 1].contiguous()
+    real_t = real.transpose(-2, -1).contiguous()
+    imag_t = imag.transpose(-2, -1).contiguous()
 
     # Compute the real part of the outer product between phasors of
     # different channels.
-    real_real = torch.matmul(unit_phasor[..., 0], unit_phasor[..., 0].transpose(-2, -1))
+    real_real = torch.matmul(real, real_t)
 
     # Compute the imaginary part of the outer product between phasors of
     # different channels.
-    imag_imag = torch.matmul(unit_phasor[..., 1], unit_phasor[..., 1].transpose(-2, -1))
+    imag_imag = torch.matmul(imag, imag_t)
 
     # Compute the cross-terms for the real and imaginary parts.
-    real_imag = torch.matmul(unit_phasor[..., 0], unit_phasor[..., 1].transpose(-2, -1))
-    imag_real = torch.matmul(unit_phasor[..., 1], unit_phasor[..., 0].transpose(-2, -1))
+    real_imag = torch.matmul(real, imag_t)
+    imag_real = torch.matmul(imag, real_t)
 
     # Combine the real and imaginary parts to form the complex correlation.
     correlation_real = real_real + imag_imag
@@ -412,7 +504,14 @@ def dwt_max_level(n_times: int, filter_len: int) -> int:
     """
     if n_times < filter_len:
         return 0
-    return max(0, int(math.floor(math.log2(n_times / (filter_len - 1)))))
+    # floor(log2(n_times / (filter_len - 1))) in integers (TorchScript has no
+    # math.log2): the largest level with (filter_len - 1) * 2**level <= n_times.
+    ratio = n_times // (filter_len - 1)
+    level = 0
+    while ratio >= 2:
+        ratio = ratio // 2
+        level += 1
+    return level
 
 
 def wavelet_decomposition(
@@ -456,8 +555,9 @@ def wavelet_decomposition(
         )
         approx, detail = F.conv1d(padded, weight, stride=2).unbind(dim=1)
         details.append(detail)
-    out = torch.cat([approx, *reversed(details)], dim=-1)
-    return out.reshape(*leading, -1)
+    details.reverse()  # [cD_n, ..., cD_1]
+    out = torch.cat([approx] + details, dim=-1)
+    return out.reshape(list(leading) + [-1])
 
 
 def sinusoidal_positional_encoding(

{braindecode-1.8.1.dev168760068 → braindecode-1.8.1.dev168889947}/braindecode/models/biot.py

@@ -1,12 +1,13 @@
+from typing import Dict, Optional, Tuple, Union
 from warnings import warn
 
 import torch
 import torch.nn as nn
-from linear_attention_transformer import LinearAttentionTransformer
 
 from braindecode.functional import sinusoidal_positional_encoding, spectral_input
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import warn_if_sfreq_differs
+from braindecode.modules.linear_attention import LinearAttentionTransformer
 
 # -----------------------------------------------------------------------------
 # Canonical BIOT channel order: the 18-channel TCP bipolar montage used by
@@ -230,7 +231,13 @@ class BIOT(EEGModuleMixin, nn.Module):
             activation=self._head_activation,
         )
 
-    def forward(self, x, return_features=False):
+    def forward(
+        self, x: torch.Tensor, return_features: bool = False
+    ) -> Union[
+        torch.Tensor,
+        Tuple[torch.Tensor, torch.Tensor],
+        Dict[str, Optional[torch.Tensor]],
+    ]:
         """
         Pass the input through the BIOT encoder, and then through the
         classification head.
@@ -255,7 +262,11 @@ class BIOT(EEGModuleMixin, nn.Module):
         emb = self.encoder(x)
 
         if return_features:
-            return {"features": emb, "cls_token": None}
+            out: Dict[str, Optional[torch.Tensor]] = {
+                "features": emb,
+                "cls_token": None,
+            }
+            return out
 
         x = self.final_layer(emb)
 
@@ -454,9 +465,7 @@ class _BIOTEncoder(nn.Module):
             dim=emb_size,
             heads=num_heads,
             depth=n_layers,
-            max_seq_len=max_seq_len,
             attn_layer_dropout=attn_layer_dropout,
-            attn_dropout=attn_dropout,
         )
         self.positional_encoding = _PositionalEncoding(emb_size, drop_prob=drop_prob)
 
@@ -497,7 +506,7 @@ class _BIOTEncoder(nn.Module):
         )
         return torch.abs(spectral).to(sample)
 
-    def forward(self, x, n_channel_offset=0, perturb=False):
+    def forward(self, x, n_channel_offset: int = 0, perturb: bool = False):
         """
         Forward pass of the BIOT encoder.
 
@@ -569,7 +578,7 @@ class _BIOTEncoder(nn.Module):
             # of time steps.
             if perturb:
                 ts = channel_emb.shape[1]
-                ts_new = torch.randint(low=ts // 2, high=ts, size=(1,)).item()
+                ts_new = int(torch.randint(low=ts // 2, high=ts, size=(1,)).item())
                 selected_ts = torch.randperm(ts)[:ts_new]
                 channel_emb = channel_emb[:, selected_ts]
             emb_seq.append(channel_emb)

{braindecode-1.8.1.dev168760068 → braindecode-1.8.1.dev168889947}/braindecode/models/brainomni.py

@@ -7,12 +7,13 @@
 # derives from Meta's EnCodec (MIT).
 from __future__ import annotations
 
+from typing import Dict, Optional, Union
+
 import mne
 import numpy as np
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from einops import rearrange
 from mne.io.constants import FIFF
 from torch.nn import RMSNorm
 from torch.nn.utils.parametrizations import weight_norm
@@ -276,8 +277,7 @@ class BrainTokenizer(EEGModuleMixin, nn.Module, license="mit"):
             feat, indices, _, _ = self._encode_quantize(x, overlap_ratio)
         finally:
             self.train(was_training)
-        flat = "batch chans nwin tok dim -> batch chans (nwin tok) dim"
-        return rearrange(feat, flat), rearrange(indices, flat)
+        return feat.flatten(2, 3), indices.flatten(2, 3)
 
 
 class BrainOmni(EEGModuleMixin, nn.Module, license="mit"):
@@ -488,18 +488,33 @@ class BrainOmni(EEGModuleMixin, nn.Module, license="mit"):
 
     def encode(self, x: torch.Tensor) -> torch.Tensor:
         """L2-normalized ``(batch, n_neuro, n_tokens, lm_dim)`` embedding."""
-        feat, _ = self.tokenizer.tokenize(x, overlap_ratio=self.overlap_ratio)
+        if torch.jit.is_scripting():
+            # TorchScript cannot switch modes, so tokenize() is not scriptable.
+            if self.tokenizer.training:
+                raise RuntimeError("Scripted BrainOmni needs tokenizer.eval().")
+            with torch.no_grad():
+                feat = self.tokenizer._encode_quantize(x, self.overlap_ratio)[0]
+            feat = feat.flatten(2, 3)
+        else:
+            feat, _ = self.tokenizer.tokenize(x, overlap_ratio=self.overlap_ratio)
         neuro = self.tokenizer.encoder.neuros.detach().to(feat.dtype)
         h = self.projection(feat + neuro.view(1, feat.shape[1], 1, -1))
-        for block in self.blocks[:-1]:
-            h = block(h)
+        for i, block in enumerate(self.blocks):  # the last block is unused, as released
+            if i < len(self.blocks) - 1:
+                h = block(h)
         return F.normalize(h, p=2.0, dim=-1, eps=1e-6)
 
-    def forward(self, x: torch.Tensor, return_features: bool = False):
+    def forward(
+        self, x: torch.Tensor, return_features: bool = False
+    ) -> Union[torch.Tensor, Dict[str, Optional[torch.Tensor]]]:
         """Classify ``x`` or return the pooled features."""
         feat = self.encode(x).mean(dim=2).flatten(1)  # (batch, n_neuro * lm_dim)
         if return_features:
-            return {"features": feat, "cls_token": None}  # nosec B105
+            out: Dict[str, Optional[torch.Tensor]] = {
+                "features": feat,
+                "cls_token": None,  # nosec B105
+            }
+            return out
         return self.final_layer(feat)
 
 
@@ -583,11 +598,11 @@ def _geometry_from_chs_info(chs_info):
     return pos, sensor_type
 
 
-def _attend(q, k, v, n_head: int, dropout_p: float, rope=None) -> torch.Tensor:
+def _attend(q, k, v, n_head: int, dropout_p: float) -> torch.Tensor:
     """SDPA over ``(batch, seq, n_head * head_dim)`` inputs."""
-    q, k, v = (t.unflatten(-1, (n_head, -1)) for t in (q, k, v))
-    if rope is not None:
-        q, k = rope(q, k)
+    q = q.unflatten(-1, (n_head, -1))
+    k = k.unflatten(-1, (n_head, -1))
+    v = v.unflatten(-1, (n_head, -1))
     out = F.scaled_dot_product_attention(
         q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2), dropout_p=dropout_p
     )
@@ -609,12 +624,13 @@ class _SpatialTemporalBlock(nn.Module):
         self.ff = FeedForwardBlock(n_dim, 4, 0.0, _SELU, output_drop_p=dropout)
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        batch, _, _, dim = x.shape
+        batch, chans, times, dim = x.shape
         h = self.pre_attn_norm(x)
-        xs = rearrange(h[..., dim // 2 :], "b c t d -> (b t) c d")
-        xt = rearrange(h[..., : dim // 2], "b c t d -> (b c) t d")
-        xs = rearrange(self.spatial_attn(xs), "(b t) c d -> b c t d", b=batch)
-        xt = rearrange(self.time_attn(xt), "(b c) t d -> b c t d", b=batch)
+        # (b, c, t, d) -> (b * t, c, d) and (b * c, t, d), and back
+        xs = h[..., dim // 2 :].permute(0, 2, 1, 3).reshape(batch * times, chans, -1)
+        xt = h[..., : dim // 2].reshape(batch * chans, times, -1)
+        xs = self.spatial_attn(xs).reshape(batch, times, chans, -1).permute(0, 2, 1, 3)
+        xt = self.time_attn(xt).reshape(batch, chans, times, -1)
         # Spatial half first: the halves swap, as released.
         x = x + torch.cat([xs, xt], dim=-1)
         return x + self.ff(self.pre_ff_norm(x))
@@ -629,6 +645,10 @@ class _RotaryPositionalEmbedding(nn.Module):
     float32 under a dtype cast, ``freqs`` follows it.
     """
 
+    # TorchScript types the ``rebuilt`` buffer from this; a postponed string
+    # annotation would not resolve.
+    __annotations__ = {"rebuilt": Optional[torch.Tensor]}
+
     def __init__(self, n_dim, base=10000):
         super().__init__()
         self.n_dim = n_dim
@@ -658,13 +678,15 @@ class _RotaryPositionalEmbedding(nn.Module):
     def forward(self, q, k):
         """Rotate ``q`` and ``k`` of shape ``(batch, seq, n_heads, head_dim)``."""
         _, seq, heads, _ = q.shape
-        rotate = self.rotate if self.rebuilt is None else self.rebuilt
+        rebuilt = self.rebuilt
+        rotate = self.rotate if rebuilt is None else rebuilt
         if seq > rotate.shape[0]:
-            self.rebuilt = rotate = self._polar(seq)
+            rotate = self._polar(seq)
+            self.rebuilt = rotate
         # In at least float32 (the cache's dtype), float64 for float64 inputs.
         work = torch.promote_types(q.dtype, torch.float32)
         rotate = rotate.to(work)[:seq].repeat_interleave(2, dim=1)
-        rotate = rearrange(rotate, "s (h d) two -> s h d two", h=heads)
+        rotate = rotate.unflatten(1, (heads, -1))  # (seq, heads, head_dim, 2)
         cos, sin = rotate[..., 0], rotate[..., 1]
         q_float, k_float = q.to(work), k.to(work)
         q_out = q_float * cos + rotate_pairs(q_float) * sin
@@ -687,7 +709,12 @@ class _MultiHeadAttentionRoPE(nn.Module):
     def forward(self, x: torch.Tensor) -> torch.Tensor:
         q, k, v = torch.split(self.qkv(x), self.n_dim, dim=-1)
         dropout_p = self.dropout if self.training else 0.0
-        out = _attend(q, k, v, self.n_head, dropout_p, self.rope_embedding_layer)
+        if self.rope_embedding_layer is not None:  # on (batch, seq, heads, head_dim)
+            q, k = self.rope_embedding_layer(
+                q.unflatten(-1, (self.n_head, -1)), k.unflatten(-1, (self.n_head, -1))
+            )
+            q, k = q.flatten(2), k.flatten(2)
+        out = _attend(q, k, v, self.n_head, dropout_p)
         return self.proj(out)
 
 
@@ -765,19 +792,22 @@ class _TokenizerEncoder(nn.Module):
         self.k_proj = nn.Linear(n_dim, n_dim)
 
     def forward(self, x: torch.Tensor, sensor_embedding: torch.Tensor):
-        batch, chans, nwin, _ = x.shape
-        x = self.seanet_encoder(rearrange(x, "b c w l -> (b c w) 1 l"))
-        x = rearrange(x, "(b c w) d t -> b c (w t) d", b=batch, c=chans, w=nwin)
-        tokens = x.shape[2]
-        sensor_embedding = rearrange(
-            sensor_embedding.unsqueeze(2).repeat(1, 1, tokens, 1),
-            "b c t d -> (b t) c d",
-        )
-        x = rearrange(x, "b c t d -> (b t) c d")
+        batch, chans, nwin, length = x.shape
+        x = self.seanet_encoder(x.reshape(batch * chans * nwin, 1, length))
+        # (b c w) d t -> b c (w t) d
+        x = x.reshape(batch, chans, nwin, x.shape[1], -1).permute(0, 1, 2, 4, 3)
+        x = x.reshape(batch, chans, -1, x.shape[-1])
+        tokens, dim = x.shape[2], x.shape[3]
+        # b c t d -> (b t) c d
+        sensor_embedding = sensor_embedding.unsqueeze(2).repeat(1, 1, tokens, 1)
+        sensor_embedding = sensor_embedding.permute(0, 2, 1, 3).reshape(-1, chans, dim)
+        x = x.permute(0, 2, 1, 3).reshape(-1, chans, dim)
         neuros = self.neuros.type_as(x).unsqueeze(0).repeat(x.shape[0], 1, 1)
         x = self.backwardsolution(neuros, self.k_proj(x + sensor_embedding), x)
-        x = rearrange(x, "(b w t) c d -> b c (w t) d", b=batch, w=nwin)
-        return rearrange(x, "b c (w t) d -> b c w t d", w=nwin)
+        # (b w t) c d -> b c (w t) d -> b c w t d
+        x = x.reshape(batch, nwin, -1, x.shape[1], dim).permute(0, 3, 1, 2, 4)
+        x = x.reshape(batch, x.shape[1], -1, dim)
+        return x.reshape(batch, x.shape[1], nwin, -1, dim)
 
 
 class _TokenizerDecoder(nn.Module):
@@ -800,16 +830,21 @@ class _TokenizerDecoder(nn.Module):
         )
 
     def forward(self, x: torch.Tensor, sensor_embedding: torch.Tensor):
-        batch, _, nwin, tok, dim = x.shape
-        x = rearrange(x, "b c w t d -> (b w t) c d")
-        sensor_embedding = rearrange(
-            sensor_embedding.view(batch, -1, 1, 1, dim).repeat(1, 1, nwin, tok, 1),
-            "b c w t d -> (b w t) c d",
+        batch, sources, nwin, tok, dim = x.shape
+        # b c w t d -> (b w t) c d
+        x = x.permute(0, 2, 3, 1, 4).reshape(-1, sources, dim)
+        sensor_embedding = sensor_embedding.view(batch, -1, 1, 1, dim)
+        chans = sensor_embedding.shape[1]
+        sensor_embedding = sensor_embedding.repeat(1, 1, nwin, tok, 1)
+        sensor_embedding = sensor_embedding.permute(0, 2, 3, 1, 4).reshape(
+            -1, chans, dim
         )
         x = self.forwardsolution(sensor_embedding, x)
-        x = rearrange(x, "(b w t) c d -> (b c w) d t", b=batch, w=nwin, t=tok)
-        x = self.seanet_decoder(x)
-        return rearrange(x, "(b c w) 1 l -> b c w l", b=batch, w=nwin)
+        # (b w t) c d -> (b c w) d t
+        x = x.reshape(batch, nwin, tok, chans, dim).permute(0, 3, 1, 4, 2)
+        x = self.seanet_decoder(x.reshape(-1, dim, tok))
+        # (b c w) 1 l -> b c w l
+        return x.reshape(batch, chans, nwin, x.shape[-1])
 
 
 class _SEANetConv1d(nn.Module):

{braindecode-1.8.1.dev168760068 → braindecode-1.8.1.dev168889947}/braindecode/models/dance.py

@@ -316,7 +316,7 @@ class DANCE(EEGModuleMixin, nn.Module, license="mit"):
     def _encode(self, x: torch.Tensor) -> torch.Tensor:
         if x.ndim != 3 or x.shape[-2] != self.n_chans:
             raise ValueError(
-                f"expected (batch, {self.n_chans}, T) input; got {tuple(x.shape)}."
+                f"expected (batch, {self.n_chans}, T) input; got {list(x.shape)}."
             )
         if x.shape[-1] < self._min_n_times:
             raise ValueError(