Braindecode 1.8.1.dev181512403__tar.gz → 1.8.1.dev181570120__tar.gz

{braindecode-1.8.1.dev181512403/braindecode.egg-info → braindecode-1.8.1.dev181570120}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.8.1.dev181512403
+Version: 1.8.1.dev181570120
 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.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/datasets/base.py

@@ -279,7 +279,7 @@ def _compact_fif_tags(inst):
     return inst
 
 
-def _read_fif_window(raw, start, stop, willneed=False):
+def _read_fif_window(raw, start, stop):
     """Samples ``start:stop`` of a lazy FIF raw, copied from the file in one go.
 
     mne reads, casts and calibrates the FIF data buffers of a range one at a
@@ -290,10 +290,6 @@ def _read_fif_window(raw, start, stop, willneed=False):
     times ``raw._cals``), so the values equal ``raw._getitem``'s. Returns None
     (the caller uses mne) unless ``raw`` is a lazy, single-file, uncompressed
     FIF raw of float32 buffers without projector, compensation or gaps.
-
-    With ``willneed=True`` nothing is read and None is returned: the OS is
-    only asked to start reading the window's bytes into the page cache in the
-    background (``posix_fadvise(POSIX_FADV_WILLNEED)``).
     """
     if (
         not isinstance(raw, mne.io.Raw)
@@ -320,18 +316,6 @@ def _read_fif_window(raw, start, stop, willneed=False):
     if not len(rows) or (rows[:, 1] != FIFF.FIFFT_FLOAT).any():
         return None
     size, pos = rows[:, 2].tolist(), rows[:, 4].tolist()
-    if willneed:  # only a hint: any error is left to the read itself
-        try:
-            with open(fname, "rb") as f:
-                os.posix_fadvise(
-                    f.fileno(),
-                    pos[0],
-                    pos[-1] + 16 + size[-1] - pos[0],
-                    os.POSIX_FADV_WILLNEED,
-                )
-        except OSError:
-            pass
-        return None
     # mmap: no copy through a 4 MB read buffer, and a cold file is read around
     # the window by the kernel (as mne's 4 MB reads did), not window by window
     with open(fname, "rb") as f, mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as m:
@@ -1378,8 +1362,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
     def __len__(self):
         return self._ensure_cumulative_sizes()[-1]
 
-    def _locate(self, idx: int):
-        """The dataset that holds item ``idx`` and the item's index in it."""
+    def _get_single_item(self, idx: int):
         if idx < 0:
             if -idx > len(self):
                 raise ValueError(
@@ -1393,33 +1376,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
             sample_idx = idx
         else:
             sample_idx = idx - cumulative_sizes[dataset_idx - 1]
-        return self.datasets[dataset_idx], sample_idx
-
-    def _get_single_item(self, idx: int):
-        ds, i = self._locate(idx)
-        return ds[i]
-
-    def __getitems__(self, indices):
-        """Items ``indices``, as ``[self[i] for i in indices]``.
-
-        A :class:`~torch.utils.data.DataLoader` fetches each batch through
-        this. The lazy FIF windows of the batch are first requested from the
-        OS all at once (``posix_fadvise(POSIX_FADV_WILLNEED)``, where it
-        exists), so their reads from disk overlap instead of running one after
-        another: on a network file system a batch read from cold files then
-        costs about one round trip, not one per window.
-        """
-        # ponytail: advises the whole batch at once; chunk it if a batch's
-        # windows ever outgrow the page cache
-        if hasattr(os, "posix_fadvise"):
-            for idx in indices:
-                if not isinstance(idx, (int, np.integer)):
-                    continue  # e.g. a SequenceSampler tuple: read, not advised
-                ds, i = self._locate(idx)
-                if isinstance(ds, EEGWindowsDataset) and ds._zarr_data is None:
-                    _, start, stop = ds.crop_inds[i].tolist()
-                    _read_fif_window(ds.raw, start, stop, willneed=True)
-        return [self[idx] for idx in indices]
+        return self.datasets[dataset_idx][sample_idx]
 
     def __getitem__(self, idx: int | list):
         """

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/functional/_real_dft.py

@@ -12,10 +12,8 @@ never downcast, so callers wrap the numerically sensitive parts with
 #
 # License: BSD (3-clause)
 import functools
-from typing import Optional
 
 import torch
-from torch import nn
 
 
 def needs_real_dft(x: torch.Tensor) -> bool:
@@ -138,56 +136,3 @@ def hilbert_freq_real(x: torch.Tensor, forward_fourier: bool) -> torch.Tensor:
         return torch.stack((out_real, out_imag), dim=-1)
 
     return compute(x)
-
-
-@torch.jit.unused
-def fft_conv1d_real(
-    x: torch.Tensor, weight: torch.Tensor, bias: Optional[torch.Tensor]
-) -> torch.Tensor:
-    """Real-valued equivalent of :func:`braindecode.functional.fft_conv1d`.
-
-    Overlap-save: the input is cut into blocks of ``n`` samples (the power of
-    two ``>= 2 * kernel_size``) that advance by ``n - kernel_size + 1`` outputs,
-    each block's DFT is a matmul against the cosine/sine basis, and per
-    frequency the complex product with the kernels, summed over the input
-    channels, is one real matmul.
-    """
-
-    @fp32_island
-    def compute(x, weight):
-        n_times, kernel_size = x.shape[-1], weight.shape[-1]
-        n = 1 << (2 * kernel_size - 1).bit_length()
-        hop = n - kernel_size + 1
-        n_blocks = -(-n_times // hop)
-        n_freqs = n // 2 + 1
-        # "same" alignment: torch pads the extra zero of an even kernel on the right
-        left = (kernel_size - 1) // 2
-        x = nn.functional.pad(x, (left, (n_blocks + 1) * hop - n_times - left))
-        hops = x.unflatten(-1, (n_blocks + 1, hop))
-        # block i = hop i + the first kernel_size - 1 samples of hop i + 1
-        blocks = torch.cat([hops[:, :, :-1], hops[:, :, 1:, : kernel_size - 1]], -1)
-        cosine, sine = real_dft_basis(n, device=x.device, dtype=x.dtype)
-        basis = torch.cat([cosine, -sine]).transpose(0, 1)  # -> [Re | Im] of rfft
-        x_f = blocks @ basis  # (batch, in, blocks, 2 * n_freqs)
-        w_f = nn.functional.pad(weight.to(x), (0, n - kernel_size)) @ basis
-        w_re, w_im = w_f[..., :n_freqs], w_f[..., n_freqs:]
-        # conv1d is a cross-correlation: x_f * conj(w_f), summed over the input
-        # channels. Per frequency [Re x, Im x] @ [[Re w, -Im w], [Im w, Re w]].
-        w_f = torch.cat([torch.cat([w_re, -w_im]), torch.cat([w_im, w_re])], 1)
-        x_f = x_f.unflatten(-1, (2, n_freqs)).permute(4, 0, 2, 3, 1).flatten(1, 2)
-        y_f = torch.bmm(x_f.flatten(2), w_f.permute(2, 1, 0))  # (freq, ., 2 * out)
-        y_f = y_f.unflatten(1, (x.shape[0], n_blocks)).unflatten(-1, (2, -1))
-        y_f = y_f.permute(1, 4, 2, 3, 0).flatten(
-            -2
-        )  # (batch, out, blocks, 2 * n_freqs)
-        # inverse DFT of the first `hop` samples, the ones without wrap-around
-        scale = torch.full((n_freqs, 1), 2.0 / n, dtype=x.dtype, device=x.device)
-        scale[0] = 1.0 / n
-        scale[-1] = 1.0 / n  # Nyquist (n is even)
-        inverse = torch.cat([scale * cosine[:, :hop], -scale * sine[:, :hop]])
-        return (y_f @ inverse).flatten(-2)[..., :n_times]
-
-    y = compute(x, weight)
-    if bias is not None:
-        y = y + bias.to(y).unsqueeze(-1)
-    return y.to(x)

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/functional/functions.py

@@ -62,10 +62,9 @@ def fft_conv1d(
 
     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
-    (see :func:`prefer_fft_conv`). float16/bfloat16 inputs are computed in
-    float32 (:func:`spectral_input`) and cast back. On Intel Gaudi (HPU, no
-    complex dtype) the DFTs are real matmuls over overlapping blocks.
+    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
     ----------
@@ -83,8 +82,6 @@ def fft_conv1d(
         ``x``. For an even ``kernel_size`` it is aligned like torch's
         ``padding="same"`` (the extra zero padded on the right).
     """
-    if _real_dft.needs_real_dft(x):
-        return _real_dft.fft_conv1d_real(x, weight, bias)
     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
@@ -118,11 +115,8 @@ def prefer_fft_conv(x: torch.Tensor, kernel_size: int) -> bool:
     and from ``batch_size * kernel_size >= 600`` if also
     ``in_channels * kernel_size >= 120``: with one or two input channels a
     float32 direct convolution stays cheaper up to k = 85 / 31 (13 long
-    temporal convolutions of the model zoo, 22 channels x batch 32). On Intel
-    Gaudi (HPU) a direct convolution costs about ``batch_size * n_times *
-    kernel_size`` and the FFT about a fixed few milliseconds in eager mode: the
-    FFT wins from 8 input channels and ``batch_size * n_times * kernel_size >=
-    8e6``. GPUs keep the direct convolution.
+    temporal convolutions of the model zoo, 22 channels x batch 32). GPUs and
+    HPUs (no complex dtype) keep the direct convolution.
 
     Parameters
     ----------
@@ -131,8 +125,6 @@ def prefer_fft_conv(x: torch.Tensor, kernel_size: int) -> bool:
     kernel_size : int
         Kernel length in samples.
     """
-    if x.device.type == "hpu":
-        return x.shape[1] >= 8 and x.shape[0] * x.shape[-1] * kernel_size >= 8e6
     return x.device.type == "cpu" and (
         x.element_size() == 2
         or (x.shape[0] * kernel_size >= 600 and x.shape[1] * kernel_size >= 120)

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/barista.py

@@ -7,13 +7,13 @@ from __future__ import annotations
 from typing import Optional
 
 import torch
+import torch.nn.functional as F
 from einops.layers.torch import Rearrange
 from torch import nn
 
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import extract_channel_locations_from_chs_info
 from braindecode.modules import GatedLinearUnit, PatchTokenizer
-from braindecode.modules.attention import _scaled_dot_product_attention
 
 
 class BaRISTA(EEGModuleMixin, nn.Module, license="other"):
@@ -689,7 +689,7 @@ class _RotarySelfAttention(nn.Module):
 
         # Dropout falls on the attention output rather than on the weights,
         # through dropout_p, because the reference disables the latter outright.
-        attention = _scaled_dot_product_attention(query, key, value)
+        attention = F.scaled_dot_product_attention(query, key, value)
         attention = self.dropout(attention)
         attention = self.merge_heads(attention)
         return self.o_proj(attention)

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/codebrain.py

@@ -703,15 +703,18 @@ class _ResidualBlock(nn.Module):
         # Sliding-window attention branch
         # (batch, 2*res_channels, seq_len) -> (batch, seq_len, 2*res_channels)
         h_attn = h_ssm.transpose(1, 2)
-        if self.swa_window_size == 1 and h_attn.device.type == "cpu":
+        if (
+            self.swa_window_size == 1
+            and not self.training
+            and not torch.is_grad_enabled()
+            and h_attn.device.type == "cpu"
+        ):
             # A one-wide window keeps only the diagonal: the softmax weights are
-            # exactly 1 and 0, so the attention returns its value projection,
-            # times the weights' dropout in training (the same (batch * heads,
-            # L, L) mask nn.MultiheadAttention draws, of which only the
-            # diagonal reaches the output). Same projection calls as
-            # nn.MultiheadAttention (on its (seq, batch, embed) view), so
-            # outputs and gradients are unchanged bit for bit, and so is the
-            # RNG stream. (On Gaudi the full attention was faster.)
+            # exactly 1 and 0, so the attention returns its value projection.
+            # Same projection calls as nn.MultiheadAttention (on its (seq,
+            # batch, embed) view), so the output is unchanged bit for bit. (In
+            # training the weights carry dropout; on Gaudi the full attention
+            # was faster.)
             # ponytail: the unused query/key projections are computed too, to
             # keep the rounding; in_proj_weight[2E:] alone is ~2x less GEMM.
             embed_dim = self.attention.embed_dim
@@ -719,16 +722,6 @@ class _ResidualBlock(nn.Module):
             value = F.linear(
                 seq_first, self.attention.in_proj_weight, self.attention.in_proj_bias
             )[..., 2 * embed_dim :]
-            p = self.attention.dropout
-            if self.training and p > 0.0:
-                n_rows = seq_first.shape[1] * self.attention.num_heads
-                keep = (
-                    value.new_empty(n_rows, seq_len, seq_len)
-                    .bernoulli_(1 - p)
-                    .diagonal(dim1=1, dim2=2)
-                    .div(1 - p)
-                )
-                value = value.reshape(seq_len, n_rows, -1) * keep.t().unsqueeze(-1)
             h_attn = (
                 self.attention.out_proj(value.reshape(-1, embed_dim))
                 .view(seq_first.shape)

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/eeginception_mi.py

@@ -60,7 +60,7 @@ class EEGInceptionMI(EEGModuleMixin, nn.Module):
         (:func:`~braindecode.functional.fft_conv1d`: same parameters, equal up
         to float rounding) instead of a direct convolution. ``None`` (default)
         decides per input with :func:`~braindecode.functional.prefer_fft_conv`
-        (FFT on CPU and HPU where it was faster in benchmarks, direct on GPU).
+        (FFT on CPU where it was faster in benchmarks, direct on GPU and HPU).
 
     References
     ----------
@@ -340,12 +340,8 @@ class _InceptionModuleMI(nn.Module):
             X1 = torch.cat([conv(X1) for conv in self.conv_list], 1)
 
         # channels_last: same values, but torch's CPU max pool then vectorises
-        # over channels instead of looping over them. CPU only: on other
-        # devices the two layout copies cost more than they save.
-        X2 = X
-        if X.device.type == "cpu":
-            X2 = X.contiguous(memory_format=torch.channels_last)
-        X2 = self.pooling(X2)
+        # over channels instead of looping over them.
+        X2 = self.pooling(X.contiguous(memory_format=torch.channels_last))
         # An even kernel_unit pools n_times + 1 samples: drop the last one.
         X2 = self.pooling_conv(X2.contiguous())[..., : X.shape[-1]]
 

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/eegnex.py

@@ -356,7 +356,7 @@ class EEGNeX(EEGModuleMixin, nn.Module):
 
 
 class _TemporalConv(nn.Conv2d):
-    """``(1, k)`` Conv2d with "same" output length; on CPU and HPU, through
+    """``(1, k)`` Conv2d with "same" output length; on CPU, through
     :func:`~braindecode.functional.fft_conv1d` where
     :func:`~braindecode.functional.prefer_fft_conv` expects it to be faster."""
 

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/eegpt.py

@@ -908,9 +908,7 @@ class _Attention(nn.Module):
         # Reshape to (3, batch, num_heads, seq_len, head_dim)
         qkv = qkv.reshape(qkv.shape[0], qkv.shape[1], 3, self.num_heads, -1)
         qkv = qkv.permute(2, 0, 3, 1, 4)
-        # unbind, not qkv[0..2]: the backward of three selects writes three
-        # zero-filled copies of the whole qkv tensor and sums them.
-        q, k, v = qkv.unbind(0)  # batch, num_heads, seq_len, head_dim
+        q, k, v = qkv[0], qkv[1], qkv[2]  # batch, num_heads, seq_len, head_dim
 
         # 1. Rotary Positional Embeddings (RoPE)
         # Unlike standard absolute positional encodings, RoPE rotates the

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/labram.py

@@ -19,7 +19,6 @@ from torch.nn.init import trunc_normal_
 from braindecode.functional import rescale_parameter
 from braindecode.models.base import EEGModuleMixin
 from braindecode.modules import MLP, DropPath
-from braindecode.modules.attention import _hpu_eager_fused_sdpa
 from braindecode.modules.blocks import PatchTokenizer
 
 # -----------------------------------------------------------------------------
@@ -1430,24 +1429,17 @@ class _Attention(nn.Module):
                 relative_position_bias.permute(2, 0, 1).contiguous().unsqueeze(0)
             )  # 1, nH, Wh*Ww, Wh*Ww
 
-        # Fused kernel, same math. Not with attention dropout in training (it
-        # would draw other masks). On Gaudi, torch's SDPA trains ~12 % slower
-        # than the plain ops; the bridge's own fused kernel (eager mode, no
-        # mask) is used instead.
-        fused = not return_attention and (self.attn_drop.p == 0.0 or not self.training)
-        out: Optional[torch.Tensor] = None
-        if fused and q.device.type != "hpu":
-            out = nn.functional.scaled_dot_product_attention(
+        # Fused kernel, same math. Not on Gaudi (Labram trains ~12 % slower there)
+        # nor with attention dropout in training (it would draw other masks).
+        if (
+            not return_attention
+            and q.device.type != "hpu"
+            and (self.attn_drop.p == 0.0 or not self.training)
+        ):
+            x = nn.functional.scaled_dot_product_attention(
                 q, k, v, attn_mask=attn_mask, scale=self.scale
             )
-        elif (
-            fused
-            and attn_mask is None
-            and not torch.jit.is_scripting()
-            and (q.dtype == torch.float32 or q.dtype == torch.bfloat16)
-        ):
-            out = _hpu_eager_fused_sdpa(q, k, v, self.scale)
-        if out is None:
+        else:
             attn = (q * self.scale) @ k.transpose(-2, -1)
             if attn_mask is not None:
                 attn = attn + attn_mask
@@ -1455,8 +1447,6 @@ class _Attention(nn.Module):
             if return_attention:
                 return attn
             x = attn @ v
-        else:
-            x = out
         x = x.transpose(1, 2).reshape(B, N, -1)
 
         x = self.proj(x)

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/luna.py

@@ -601,9 +601,7 @@ class _RotarySelfAttentionBlock(nn.Module):
             .reshape(B, N, 3, self.num_heads, C // self.num_heads)
             .permute(2, 0, 3, 1, 4)
         )  # (K, B, H, N, D)
-        # unbind, not qkv[0..2]: the backward of three selects writes three
-        # zero-filled copies of the whole qkv tensor and sums them.
-        q, k, v = qkv.unbind(0)
+        q, k, v = qkv[0], qkv[1], qkv[2]
         q = self._rotate_queries_or_keys(q)
         k = self._rotate_queries_or_keys(k)
         attn = F.scaled_dot_product_attention(

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/patchedtransformer.py

@@ -12,7 +12,6 @@ import torch.nn as nn
 import torch.nn.functional as F
 
 from braindecode.models.base import EEGModuleMixin
-from braindecode.modules.attention import _scaled_dot_product_attention
 
 
 class PBT(EEGModuleMixin, nn.Module):
@@ -412,8 +411,13 @@ class _MHSA(nn.Module):
         k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
         v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)
 
-        y = _scaled_dot_product_attention(
-            q, k, v, dropout_p=self.drop_prob if self.training else 0.0
+        y = torch.nn.functional.scaled_dot_product_attention(
+            q,
+            k,
+            v,
+            attn_mask=None,
+            dropout_p=self.drop_prob if self.training else 0.0,
+            is_causal=False,
         )
 
         # re-assemble heads -> (B, T, C)

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/reve.py

@@ -15,10 +15,9 @@ import torch
 import torch.nn.functional as F
 from mne.datasets.utils import _get_path
 from torch import nn
+from torch.nn import RMSNorm
 
 from braindecode.models.base import EEGModuleMixin
-from braindecode.modules.attention import _scaled_dot_product_attention
-from braindecode.modules.layers import RMSNorm
 
 logger = logging.getLogger(__name__)
 
@@ -440,8 +439,7 @@ class REVE(EEGModuleMixin, nn.Module):
                 raise ValueError(
                     "No positions provided and no default positions available. Please provide channel positions."
                 )
-            # One copy for the whole batch: the embedding below broadcasts.
-            pos = self.default_pos.unsqueeze(0).to(eeg.device)
+            pos = self.default_pos.expand(batch_size, -1, -1).to(eeg.device)
 
         pos = FourierEmb4D.add_time_patch(pos, n_patches)
         # Positions stay in float32 for the Fourier features; the embedding
@@ -520,7 +518,6 @@ class GEGLU(nn.Module):
 class FeedForward(nn.Module):
     def __init__(self, dim: int, hidden_dim: int, geglu: bool):
         super().__init__()
-        self.geglu = geglu
         self.net = nn.Sequential(
             RMSNorm(dim, eps=1e-6),
             nn.Linear(dim, hidden_dim * 2 if geglu else hidden_dim, bias=False),
@@ -529,15 +526,7 @@ class FeedForward(nn.Module):
         )
 
     def forward(self, x: torch.Tensor) -> torch.Tensor:
-        if not self.geglu:
-            return self.net(x)
-        # GEGLU halves as two matmuls on the weight's row halves: contiguous
-        # outputs instead of strided views of one output (copied on HPU).
-        x = self.net[0](x)
-        weight = self.net[1].weight
-        half = weight.shape[0] // 2
-        x, gates = F.linear(x, weight[:half]), F.linear(x, weight[half:])
-        return self.net[3](F.gelu(gates) * x)
+        return self.net(x)
 
 
 #################################################################################
@@ -565,8 +554,7 @@ class Attention(nn.Module):
         q = q.unflatten(-1, (self.heads, -1)).transpose(1, 2)
         k = k.unflatten(-1, (self.heads, -1)).transpose(1, 2)
         v = v.unflatten(-1, (self.heads, -1)).transpose(1, 2)
-        # ~700-token sequences: the fused kernel also beats lazy mode's graph.
-        out = _scaled_dot_product_attention(q, k, v, fused_in_lazy=True)
+        out = F.scaled_dot_product_attention(q, k, v)
         return self.to_out(out.transpose(1, 2).flatten(2))
 
 

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/models/zuna.py

@@ -12,12 +12,11 @@ import torch
 from einops import rearrange
 from einops.layers.torch import Rearrange
 from torch import nn
-from torch.nn import RMSNorm
+from torch.nn import RMSNorm, functional
 
 from braindecode.models.base import EEGModuleMixin
 from braindecode.models.util import extract_channel_locations_from_chs_info
 from braindecode.modules import PatchTokenizer
-from braindecode.modules.attention import _scaled_dot_product_attention
 
 
 class ZUNA(EEGModuleMixin, nn.Module, license="apache-2.0"):
@@ -404,16 +403,18 @@ class _RotaryPositionEmbedding(nn.Module):
 
         batch_size, sequence_length, num_heads, head_dim = query.shape
         work = torch.promote_types(query.dtype, torch.float32)
-        # Each (real, imaginary) pair (a, b) rotates to (-b, a): swap the pair
-        # here; the sign is in ``rotary_sine`` (see _ZUNAEncoder).
         query_pairs = query.to(work).reshape(
             batch_size, sequence_length, num_heads, head_dim // 2, 2
         )
         key_pairs = key.to(work).reshape(
             batch_size, sequence_length, num_heads, head_dim // 2, 2
         )
-        rotated_query = self.merge_rotary_pairs(query_pairs.flip(-1))
-        rotated_key = self.merge_rotary_pairs(key_pairs.flip(-1))
+        rotated_query = self.merge_rotary_pairs(
+            torch.stack((-query_pairs[..., 1], query_pairs[..., 0]), dim=-1)
+        )
+        rotated_key = self.merge_rotary_pairs(
+            torch.stack((-key_pairs[..., 1], key_pairs[..., 0]), dim=-1)
+        )
 
         query = (query.to(work) * rotary_cosine + rotated_query * rotary_sine).type_as(
             query
@@ -464,7 +465,7 @@ class _Attention(nn.Module):
         value = self.wv(input_tensor).reshape(attention_shape)
         query, key = self.rotary_embedding(query, key, rotary_cosine, rotary_sine)
 
-        attention_output = _scaled_dot_product_attention(
+        attention_output = functional.scaled_dot_product_attention(
             query.transpose(1, 2),
             key.transpose(1, 2),
             value.transpose(1, 2),
@@ -605,12 +606,9 @@ class _ZUNAEncoder(nn.Module):
             rotary_frequencies.cos(),
             persistent=False,
         )
-        # Sine with the pair rotation's sign folded in: -sin on the real, +sin
-        # on the imaginary component of every pair (exact, saves a negation).
-        pair_sign = torch.tensor([-1.0, 1.0]).repeat(rotary_frequencies.shape[-1] // 2)
         self.register_buffer(
             "rotary_sine",
-            rotary_frequencies.sin() * pair_sign,
+            rotary_frequencies.sin(),
             persistent=False,
         )
 

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/modules/attention.py

@@ -834,57 +834,6 @@ class CATLite(nn.Module):
         return channel_score * x
 
 
-@torch.jit.unused
-def _hpu_eager_fused_sdpa(
-    query: Tensor,
-    key: Tensor,
-    value: Tensor,
-    scale: Optional[float] = None,
-    fused_in_lazy: bool = False,
-) -> Optional[Tensor]:
-    # Lazy mode: None, the graph compiler already fuses torch's SDPA there
-    # (unless the caller measured the fused kernel faster for its shapes).
-    from habana_frameworks.torch.utils.internal import is_lazy
-
-    if is_lazy() and not fused_in_lazy:
-        return None
-    from habana_frameworks.torch.hpex.kernels import FusedSDPA
-
-    return FusedSDPA.apply(query, key, value, None, 0.0, False, scale, "None", False)
-
-
-def _scaled_dot_product_attention(
-    query: Tensor,
-    key: Tensor,
-    value: Tensor,
-    attn_mask: Optional[Tensor] = None,
-    dropout_p: float = 0.0,
-    fused_in_lazy: bool = False,
-) -> Tensor:
-    """``F.scaled_dot_product_attention``; Gaudi's fused kernel on HPU.
-
-    In HPU eager mode, torch's SDPA runs op by op (the full
-    ``(batch, heads, seq, seq)`` scores in device memory), 2-3.5x slower than
-    the bridge's fused kernel on long sequences. The fused kernel is used
-    without a mask or dropout (its dropout would draw other masks). In lazy
-    mode only with ``fused_in_lazy=True``: the graph compiler fuses torch's
-    SDPA too, faster on long sequences, slower on short ones.
-    """
-    if (
-        not torch.jit.is_scripting()
-        and query.device.type == "hpu"
-        and attn_mask is None
-        and dropout_p == 0.0
-        and (query.dtype == torch.float32 or query.dtype == torch.bfloat16)
-    ):
-        out = _hpu_eager_fused_sdpa(query, key, value, fused_in_lazy=fused_in_lazy)
-        if out is not None:
-            return out
-    return F.scaled_dot_product_attention(
-        query, key, value, attn_mask=attn_mask, dropout_p=dropout_p
-    )
-
-
 class MultiHeadAttention(nn.Module):
     """Multi-head self-attention block.
 
@@ -958,8 +907,12 @@ class MultiHeadAttention(nn.Module):
         dp = self.att_drop if self.training else 0.0
         if self.scale is not None:
             queries = queries * (self.scale * self.head_dim**0.5)
-        out = _scaled_dot_product_attention(
-            queries, keys, values, attn_mask=mask, dropout_p=dp
+        out = F.scaled_dot_product_attention(
+            queries,
+            keys,
+            values,
+            attn_mask=mask,
+            dropout_p=dp,
         )
 
         out = self.rearrange_unstack(out)

{braindecode-1.8.1.dev181512403 → braindecode-1.8.1.dev181570120}/braindecode/modules/dance_modules.py

@@ -10,11 +10,11 @@ import math
 from typing import Dict, Optional
 
 import torch
+import torch.nn.functional as F
 from torch import nn
 
 from braindecode.functional import sinusoidal_positional_encoding
 from braindecode.modules.activation import GatedLinearUnit
-from braindecode.modules.attention import _scaled_dot_product_attention
 from braindecode.modules.layers import ChannelMerger
 
 
@@ -28,19 +28,7 @@ class _ConvBlock(nn.Module):
         self.act = None if last else activation()
 
     def forward(self, x):
-        # Taps more than (T - 1) // dilation steps off-centre only ever read the
-        # zero padding: drop them (the same sum without its zero terms, fewer
-        # multiply-adds at long dilations).
-        d = self.conv.dilation[0]
-        half = self.conv.kernel_size[0] // 2
-        reach = (x.shape[-1] - 1) // d
-        if reach < half:
-            weight = self.conv.weight[:, :, half - reach : half + reach + 1]
-            x = nn.functional.conv1d(
-                x, weight, self.conv.bias, padding=reach * d, dilation=d
-            )
-        else:
-            x = self.conv(x)
+        x = self.conv(x)
         if self.act is not None:
             x = self.act(x)
         return x
@@ -189,8 +177,7 @@ class _Attention(nn.Module):
         q = q.unflatten(-1, (h, -1)).transpose(1, 2)
         k = k.unflatten(-1, (h, -1)).transpose(1, 2)
         v = v.unflatten(-1, (h, -1)).transpose(1, 2)
-        # scale = dim_head ** -0.5 = SDPA's default 1 / sqrt(q.shape[-1])
-        out = _scaled_dot_product_attention(q, k, v)
+        out = F.scaled_dot_product_attention(q, k, v, scale=self.scale)
         # (b, h, n, d) -> (b, n, h * d)
         return self.to_out(out.transpose(1, 2).flatten(2))