Braindecode 1.5.0.dev902__tar.gz → 1.5.0.dev982__tar.gz

{braindecode-1.5.0.dev902/braindecode.egg-info → braindecode-1.5.0.dev982}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.5.0.dev902
+Version: 1.5.0.dev982
 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.5.0.dev902 → braindecode-1.5.0.dev982}/braindecode/datasets/base.py

@@ -298,95 +298,34 @@ def _build_windowed_repr(
 
 
 def _zarr_to_memmap(zarr_path, group_name):
-    """Materialise a zarr array as a float64 ``.npy`` memmap, race-free.
-
-    Decompress the ``group_name`` array inside ``zarr_path`` into a
-    float64 ``.npy`` file inside a sibling ``.<zarr>_memmap/`` cache
-    directory and return the path to that file.  The dtype is float64
-    because MNE objects wrap the memmap zero-copy and MNE requires
-    float64 internally.  Callers open the result with
-    ``np.load(path, mmap_mode='c')`` so preprocessing writes land in
-    anonymous copy-on-write pages and never mutate the on-disk file.
-
-    Concurrency contract
-    --------------------
-    Safe to call from any number of threads or processes concurrently
-    on the same ``(zarr_path, group_name)``, on local POSIX, NFSv3,
-    Lustre and SMB.  The published ``.npy`` file is **created exactly
-    once and never replaced**: subsequent callers either hit the
-    already-materialised file on the fast path or lose the
-    publication race and discard their own copy.
-
-    The atomic publication step is ``os.link``, not ``rename``.
-    ``os.link(tmp, dst)`` either creates ``dst`` pointing at ``tmp``'s
-    inode or fails with :class:`FileExistsError` when ``dst`` already
-    exists — the "create only if absent" primitive we need, available
-    on every POSIX filesystem.  ``rename`` was the wrong primitive:
-    it atomically *replaces* its destination, which unlinks the inode
-    that concurrent readers may already have ``mmap``'d.  On NFSv3
-    that produced ``.nfsXXXX`` silly-rename files and intermittent
-    ``SIGBUS`` when workers page-faulted on the unlinked inode.
-
-    Under ``N`` concurrent writers, every racer materialises the data
-    into its own per-pid temp file and then tries to publish it; at
-    most one ``os.link`` wins, and the losers silently ``unlink``
-    their temp file in a ``finally`` block.  The wasted I/O scales
-    with the number of racers; for the workloads braindecode targets
-    (a handful of concurrent workers per group) it is negligible.
-
-    Crash recovery: if a writer dies mid-run the only debris is a
-    ``<group>.<pid>.tmp.npy`` file.  Such files are namespaced by pid
-    so they can never collide with a live writer, they are never
-    read by the fast path, and they do not prevent subsequent
-    callers from producing a correct result.  Caches written by
-    earlier braindecode versions remain valid: the fast path only
-    requires ``<group>.npy`` to exist.
+    """Decompress a zarr array to a float64 ``.npy`` memmap (one-time, atomic).
+
+    Saved as float64 so MNE objects can wrap the memmap zero-copy
+    (MNE requires float64 internally).  Copy-on-write mode (``'c'``)
+    means preprocessing writes go to RAM, the file stays untouched.
     """
     zarr_p = Path(zarr_path)
     cache_dir = zarr_p.parent / f".{zarr_p.name}_memmap"
     npy_path = cache_dir / f"{group_name}.npy"
 
-    # Fast path: the file is already fully materialised.  A single
-    # stat() is all the steady-state workload pays.
-    if npy_path.exists():
-        return npy_path
-
-    cache_dir.mkdir(parents=True, exist_ok=True)
-    arr = zarr.open(zarr_path, mode="r")[group_name]["data"]
-    tmp_path = cache_dir / f"{group_name}.{os.getpid()}.tmp.npy"
-    try:
-        # Write chunk-by-chunk to avoid materialising the whole zarr
-        # array in RAM.
+    if not npy_path.exists():
+        arr = zarr.open(zarr_path, mode="r")[group_name]["data"]
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        tmp_path = cache_dir / f"{group_name}.{os.getpid()}.tmp.npy"
+        # Write chunk-by-chunk to avoid materializing the full array in RAM
         mm = np.lib.format.open_memmap(
             tmp_path, mode="w+", dtype=np.float64, shape=arr.shape
         )
+        chunk0 = arr.chunks[0] if hasattr(arr, "chunks") else arr.shape[0]
+        for start in range(0, arr.shape[0], chunk0):
+            end = min(start + chunk0, arr.shape[0])
+            mm[start:end] = np.asarray(arr[start:end], dtype=np.float64)
+        mm.flush()
+        del mm
         try:
-            chunk0 = arr.chunks[0] if hasattr(arr, "chunks") else arr.shape[0]
-            for start in range(0, arr.shape[0], chunk0):
-                end = min(start + chunk0, arr.shape[0])
-                mm[start:end] = np.asarray(arr[start:end], dtype=np.float64)
-            mm.flush()
-        finally:
-            del mm
-
-        # Atomic publication.  ``os.link`` never replaces an existing
-        # destination, so the published inode is immutable for the
-        # lifetime of the cache directory.  Concurrent readers never
-        # see their mmap'd inode vanish from under them.
-        try:
-            os.link(tmp_path, npy_path)
-        except FileExistsError:
-            # Another writer beat us to it.  Their file is the
-            # canonical one; ours is discarded in the finally block.
-            pass
-    finally:
-        # Always remove our private per-pid temp file.  It is
-        # namespaced by pid so this cannot clobber a concurrent
-        # writer's in-progress tmp file.
-        try:
-            os.unlink(tmp_path)
-        except FileNotFoundError:
-            pass
+            tmp_path.rename(npy_path)
+        except OSError:
+            tmp_path.unlink(missing_ok=True)
 
     return npy_path
 

{braindecode-1.5.0.dev902 → braindecode-1.5.0.dev982}/braindecode/models/attentionbasenet.py

@@ -1,8 +1,5 @@
 from __future__ import annotations
 
-# Authors: Sarthak Tayal <sarthaktayal2@gmail.com>
-#
-# License: BSD (3-clause)
 import math
 
 from einops.layers.torch import Rearrange
@@ -278,6 +275,8 @@ class AttentionBaseNet(EEGModuleMixin, nn.Module):
         activation: type[nn.Module] = nn.ELU,
         extra_params: bool = False,
     ):
+        super(AttentionBaseNet, self).__init__()
+
         super().__init__(
             n_outputs=n_outputs,
             n_chans=n_chans,

{braindecode-1.5.0.dev902 → braindecode-1.5.0.dev982}/braindecode/models/syncnet.py

@@ -1,7 +1,3 @@
-# Authors: Sarthak Tayal <sarthaktayal2@gmail.com>
-#
-# License: BSD (3-clause)
-
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
@@ -55,11 +51,11 @@ class SyncNet(EEGModuleMixin, nn.Module):
         The initialization range for omega parameters using uniform
         distribution. Default is (0, 1).
     beta_init_values : tuple of float, optional
-        The initialization range for beta (decay) parameters using uniform
-        distribution. Default is (0, 0.05).
+        The initialization range for beta parameters using uniform
+        distribution. Default is (0, 1). Default is (0, 0.05).
     phase_init_values : tuple of float, optional
-        The initialization mean and standard deviation for phase
-        parameters using normal distribution. Default is (0, 0.05).
+        The initialization range for phase parameters using `normal`
+        distribution. Default is (0, 1). Default is (0, 0.05).
 
 
     Notes
@@ -150,12 +146,12 @@ class SyncNet(EEGModuleMixin, nn.Module):
         # Phase Shift
         self.phi_ini = nn.Parameter(
             torch.FloatTensor(1, 1, self.n_chans, self.num_filters).normal_(
-                self.phase_init_values[0], self.phase_init_values[1]
+                self.beta_init_values[0], self.beta_init_values[1]
             )
         )
         self.beta = nn.Parameter(
             torch.FloatTensor(1, 1, 1, self.num_filters).uniform_(
-                self.beta_init_values[0], self.beta_init_values[1]
+                self.phase_init_values[0], self.phase_init_values[1]
             )
         )
 
@@ -189,21 +185,21 @@ class SyncNet(EEGModuleMixin, nn.Module):
         # Output: (batch_size, n_chans, 1, n_times)
 
         # Compute the oscillatory component
-        # Shape: (1, filter_width, n_chans, num_filters)
         W_osc = self.amplitude * torch.cos(self.t * self.omega + self.phi_ini)
+        # W_osc is (1, filter_width, n_chans, 1)
 
         # Compute the decay component
-        # Shape: (1, filter_width, 1, num_filters)
-        t_squared = torch.pow(self.t, 2)
-        t_squared_beta = t_squared * self.beta
+        t_squared = torch.pow(self.t, 2)  # Shape: (filter_width,)
+        t_squared_beta = t_squared * self.beta  # Shape: (filter_width, num_filters)
         W_decay = torch.exp(-t_squared_beta)
+        # W_osc is (1, filter_width, 1, 1)
 
         # Combine oscillatory and decay components
-        # Shape: (1, filter_width, n_chans, num_filters)
+        # W shape: (1, n_chans, num_filters, filter_width)
         W = W_osc * W_decay
+        # W shape will be: (1, filter_width, n_chans, 1)
 
-        # Permute to conv2d weight shape (out_channels, in_channels, kH, kW)
-        W = W.permute(3, 2, 0, 1).contiguous()
+        W = W.view(self.num_filters, self.n_chans, 1, self.filter_width)
 
         # Apply convolution
         x_padded = self.pad_input(x.float())

{braindecode-1.5.0.dev902 → braindecode-1.5.0.dev982}/braindecode/models/tsinception.py

@@ -1,4 +1,4 @@
-# Authors: Bruno Aristimunha <b.aristimunha@gmail.com>
+# Authors: Bruno Aristimunha <b.aristimunha>
 #
 # License: BSD (3-clause)
 

{braindecode-1.5.0.dev902 → braindecode-1.5.0.dev982}/braindecode/modules/attention.py

@@ -837,18 +837,6 @@ class CATLite(nn.Module):
 class MultiHeadAttention(nn.Module):
     """Multi-head self-attention block.
 
-    Uses ``F.scaled_dot_product_attention`` for optimized attention
-    kernels (flash-attention on CUDA, memory-efficient on other devices).
-
-    Parameters
-    ----------
-    emb_size : int
-        The embedding dimension.
-    num_heads : int
-        Number of attention heads. Must evenly divide ``emb_size``.
-    dropout : float, optional
-        Dropout probability applied to attention weights. Default: 0.0.
-
     Examples
     --------
     >>> import torch
@@ -860,57 +848,40 @@ class MultiHeadAttention(nn.Module):
     torch.Size([2, 10, 32])
     """
 
-    def __init__(self, emb_size, num_heads, dropout=0.0):
+    def __init__(self, emb_size, num_heads, dropout):
         super().__init__()
-        if emb_size % num_heads != 0:
-            raise ValueError(
-                f"emb_size ({emb_size}) must be divisible by num_heads ({num_heads})."
-            )
         self.emb_size = emb_size
         self.num_heads = num_heads
-        self.head_dim = emb_size // num_heads
         self.keys = nn.Linear(emb_size, emb_size)
         self.queries = nn.Linear(emb_size, emb_size)
         self.values = nn.Linear(emb_size, emb_size)
-        self.att_drop = dropout
+        self.att_drop = nn.Dropout(dropout)
         self.projection = nn.Linear(emb_size, emb_size)
 
         self.rearrange_stack = Rearrange(
-            "batch seq (heads head_dim) -> batch heads seq head_dim",
-            heads=num_heads,
+            "b n (h d) -> b h n d",
+            h=num_heads,
         )
         self.rearrange_unstack = Rearrange(
-            "batch heads seq head_dim -> batch seq (heads head_dim)",
+            "b h n d -> b n (h d)",
         )
 
     def forward(self, x: Tensor, mask: Optional[Tensor] = None) -> Tensor:
-        """Forward pass.
-
-        Parameters
-        ----------
-        x : Tensor
-            Input tensor of shape ``(batch, seq, emb_size)``.
-        mask : Tensor, optional
-            Attention mask following PyTorch SDPA convention: for boolean
-            masks ``True`` means **ignore** that position; for float
-            masks the values are **added** to attention scores before
-            softmax.
-        """
         queries = self.rearrange_stack(self.queries(x))
         keys = self.rearrange_stack(self.keys(x))
         values = self.rearrange_stack(self.values(x))
-
-        dp = self.att_drop if self.training else 0.0
-        out = F.scaled_dot_product_attention(
-            queries,
-            keys,
-            values,
-            attn_mask=mask,
-            dropout_p=dp,
-        )
-
+        energy = torch.einsum("bhqd, bhkd -> bhqk", queries, keys)
+        if mask is not None:
+            fill_value = float("-inf")
+            energy = energy.masked_fill(~mask, fill_value)
+
+        scaling = self.emb_size ** (1 / 2)
+        att = F.softmax(energy / scaling, dim=-1)
+        att = self.att_drop(att)
+        out = torch.einsum("bhal, bhlv -> bhav ", att, values)
         out = self.rearrange_unstack(out)
-        return self.projection(out)
+        out = self.projection(out)
+        return out
 
 
 class CrissCrossTransformerEncoderLayer(nn.Module):

braindecode-1.5.0.dev982/braindecode/version.py

@@ -0,0 +1 @@
+__version__ = "1.5.0.dev982"

{braindecode-1.5.0.dev902 → braindecode-1.5.0.dev982/braindecode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.5.0.dev902
+Version: 1.5.0.dev982
 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.5.0.dev902 → braindecode-1.5.0.dev982}/docs/install/install.rst

@@ -4,7 +4,7 @@
  Installation
 ##############
 
-Braindecode is written in Python 3, specifically for version 3.11 or above.
+Braindecode is written in Python 3, specifically for version 3.10 or above.
 
 The package is distributed via Python package index (`PyPI <braindecode-pypi_>`_), and
 you can access the source code via `Github <braindecode-github_>`_ repository.

{braindecode-1.5.0.dev902 → braindecode-1.5.0.dev982}/docs/whats_new.rst

@@ -28,19 +28,10 @@ Current 1.5.0 (GitHub)
 Enhancements
 ============
 
-- Use ``F.scaled_dot_product_attention`` in :class:`braindecode.modules.MultiHeadAttention`,
-  enabling optimized attention kernels (flash-attention on CUDA,
-  memory-efficient backends on other devices).
-  By `Léo Burgund`_ and `Bruno Aristimunha`_.
-  (:gh:`902`)
-
 API and behavior changes
 ========================
 
-- :class:`braindecode.modules.MultiHeadAttention` now follows PyTorch's SDPA mask
-  convention: boolean masks use ``True`` to **ignore** a position (previously
-  ``True`` meant keep). The scaling factor is now ``1/sqrt(head_dim)`` instead of
-  ``1/sqrt(emb_size)``. (:gh:`902`)
+- None yet
 
 Requirements
 ============
@@ -50,25 +41,7 @@ Requirements
 Bug fixes
 ==========
 
-- Fix :class:`braindecode.models.SyncNet` swapped parameter initialization where
-  ``phi_ini`` (phase shift) was using ``beta_init_values`` and ``beta`` (decay) was
-  using ``phase_init_values``, replaced incorrect ``.view()`` reshape with ``.permute()``
-  for proper conv2d filter weight layout, and fixed duplicate default values in docstring
-  (by `Sarthak Tayal`_)
-- Fix :class:`braindecode.models.AttentionBaseNet` redundant
-  ``super().__init__()`` call that ran the parent ``nn.Module.__init__`` twice
-  (by `Sarthak Tayal`_)
-- Fix incomplete author email in :class:`braindecode.models.TSception` header
-  (by `Sarthak Tayal`_)
-- Fix a time-of-check-time-of-use race in
-  :func:`braindecode.datasets.base._zarr_to_memmap` that caused
-  concurrent workers to repeatedly ``rename``-replace the published
-  ``.npy`` cache, producing wasted I/O on local filesystems and
-  ``.nfsXXXX`` silly-rename files plus ``SIGBUS`` crashes on NFSv3.
-  The published file is now created exactly once via ``os.link`` and
-  is never replaced, making the cache safe under arbitrary
-  concurrent access on local POSIX, NFSv3, Lustre and SMB
-  (:gh:`986` by `Pierre Guetschel`_)
+- None yet
 
 Code health
 ============

braindecode-1.5.0.dev902/braindecode/version.py

@@ -1 +0,0 @@
-__version__ = "1.5.0.dev902"