Braindecode 1.3.2.dev182822510__tar.gz → 1.3.2.dev183191339__tar.gz

{braindecode-1.3.2.dev182822510/braindecode.egg-info → braindecode-1.3.2.dev183191339}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.3.2.dev182822510
+Version: 1.3.2.dev183191339
 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>
@@ -22,7 +22,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
 License-File: NOTICE.txt
-Requires-Dist: torch>=2.2
+Requires-Dist: torch>=2.0
 Requires-Dist: torchaudio>=2.0
 Requires-Dist: mne>=1.11.0
 Requires-Dist: pandas<3.0.0
@@ -35,7 +35,7 @@ Requires-Dist: wfdb
 Requires-Dist: linear_attention_transformer
 Requires-Dist: docstring_inheritance
 Requires-Dist: rotary_embedding_torch
-Requires-Dist: pandas<3.0.0
+Requires-Dist: pydantic>=2.0
 Provides-Extra: moabb
 Requires-Dist: moabb>=1.4.3; extra == "moabb"
 Provides-Extra: eegprep

{braindecode-1.3.2.dev182822510 → braindecode-1.3.2.dev183191339}/braindecode/datasets/base.py

@@ -579,6 +579,89 @@ class EEGWindowsDataset(RecordDataset):
             self.metadata,
         )
 
+    def to_epochs_dataset(self) -> WindowsDataset:
+        """Converts this :class:`EEGWindowsDataset` to :class:`WindowsDataset` with ``mne.Epochs``.
+
+        In Braindecode, the data can either be stored as ``mne.io.Raw`` (in :class:`EEGWindowsDataset`)
+        or as ``mne.Epochs`` (in :class:`WindowsDataset`). This function converts from the first type to the second,
+        which can be useful for reducing disk space when you want to save a dataset.
+
+        Returns
+        -------
+        WindowsDataset
+            A new :class:`WindowsDataset` with ``mne.Epochs``.
+
+        Raises
+        ------
+        ValueError
+            If the dataset is not compatible with conversion. This includes:
+            - If targets are not obtained from metadata
+            - If windows have inconsistent sizes or there are no windows to convert
+            - If raw.first_samp!=0 (not supported for simplicity)
+        """
+        # Check the targets:
+        if self.targets_from != "metadata":
+            raise ValueError(
+                "to_epochs_dataset only works if targets are obtained from metadata."
+            )
+
+        # Check and get window sizes:
+        i_start_in_trial = self.crop_inds[:, 1]
+        i_stop_in_trial = self.crop_inds[:, 2]
+        sizes = np.unique(i_stop_in_trial - i_start_in_trial)
+        if len(sizes) > 1:
+            raise ValueError("Windows have inconsistent sizes.")
+        if len(sizes) != 1:
+            raise ValueError("No windows to convert.")
+        input_window_seconds = (sizes[0] - 1) / self.raw.info["sfreq"]
+
+        # Check raw.first_samp:
+        if self.raw.first_samp != 0:
+            raise ValueError(
+                f"to_epochs_dataset only works if raw.first_samp is 0, found {self.raw.first_samp=}"
+            )
+
+        # Create events and epochs:
+        events = np.zeros((len(self), 3), dtype=int)
+        events[:, 0] = i_start_in_trial
+        events[:, 2] = 1
+        epochs = mne.Epochs(
+            raw=self.raw,
+            events=events,
+            event_id={"window": 1},
+            tmin=0,
+            tmax=input_window_seconds,
+            metadata=self.metadata.copy(),
+            baseline=None,
+        )
+        # we skip dropping bads to be consistent with EEGWindowsDataset:
+        epochs._bad_dropped = True
+
+        # Populate new WindowsDataset:
+        windows = WindowsDataset(
+            epochs,
+            description=self.description,
+            transform=self.transform,
+            targets_from=self.targets_from,
+            last_target_only=self.last_target_only,
+        )
+
+        window_kwargs = list(getattr(self, "window_kwargs", []))
+        window_kwargs.append((self.to_epochs_dataset.__name__, {}))
+        setattr(windows, "window_kwargs", window_kwargs)
+        if hasattr(self, "raw_preproc_kwargs"):
+            setattr(
+                windows, "raw_preproc_kwargs", list(getattr(self, "raw_preproc_kwargs"))
+            )
+        if hasattr(self, "window_preproc_kwargs"):
+            setattr(
+                windows,
+                "window_preproc_kwargs",
+                list(getattr(self, "window_preproc_kwargs")),
+            )
+
+        return windows
+
 
 @register_dataset
 class WindowsDataset(RecordDataset):
@@ -732,7 +815,9 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
 
     def __init__(
         self,
-        list_of_ds: list[T | BaseConcatDataset[T]],
+        list_of_ds: (
+            list[T] | list[BaseConcatDataset[T]] | list[T | BaseConcatDataset[T]]
+        ),
         target_transform: Callable | None = None,
         *,
         lazy: bool = False,
@@ -1309,3 +1394,40 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
 
     def _repr_html_(self):
         return self._build_repr().to_html()
+
+    def to_epochs_dataset(self) -> BaseConcatDataset[WindowsDataset]:
+        """Converts this :class:`BaseConcatDataset` such that all datasets are :class:`WindowsDataset` with ``mne.Epochs``.
+
+        In Braindecode, the data can either be stored as ``mne.io.Raw`` (in :class:`EEGWindowsDataset`)
+        or as ``mne.Epochs`` (in :class:`WindowsDataset`). This function converts all the underlying datasets to
+        :class:`WindowsDataset` with ``mne.Epochs``.
+        This can be useful for reducing disk space when you want to save a dataset.
+
+        Returns
+        -------
+        BaseConcatDataset[WindowsDataset]
+            A new :class:`BaseConcatDataset` where all datasets are :class:`WindowsDataset` with ``mne.Epochs``.
+
+        Raises
+        ------
+        ValueError
+            If any of the underlying datasets is a :class:`RawDataset` or any other type that is not
+            :class:`EEGWindowsDataset` or :class:`WindowsDataset`, as they cannot be converted to epochs.
+        """
+        datasets = self.datasets
+        if not all(
+            isinstance(ds, (EEGWindowsDataset, WindowsDataset)) for ds in datasets
+        ):
+            raise ValueError(
+                "All datasets must be EEGWindowsDataset or WindowsDataset to convert to WindowsDataset."
+            )
+        new_datasets: list[WindowsDataset] = []
+        for ds in datasets:
+            if isinstance(ds, EEGWindowsDataset):
+                new_ds = ds.to_epochs_dataset()
+                new_datasets.append(new_ds)
+            elif isinstance(ds, WindowsDataset):
+                new_datasets.append(ds)
+        return BaseConcatDataset(
+            new_datasets, target_transform=self.target_transform, lazy=self._lazy
+        )

{braindecode-1.3.2.dev182822510 → braindecode-1.3.2.dev183191339}/braindecode/datasets/bids/hub.py

@@ -103,7 +103,7 @@ class HubDatasetMixin:
         compression: str = "blosc",
         compression_level: int = 5,
         pipeline_name: str = "braindecode",
-        chunk_size: int = 10000,
+        chunk_size: int = 5_000_000,
         local_cache_dir: str | Path | None = None,
         **kwargs,
     ) -> str:
@@ -129,10 +129,13 @@ class HubDatasetMixin:
             Compression level (0-9). Level 5 provides optimal balance.
         pipeline_name : str, default="braindecode"
             Name of the processing pipeline for BIDS sourcedata.
-        chunk_size : int, default=10000
-            Number of samples per chunk in Zarr. Larger chunk size will create fewer
-            but larger files. Only used for RawDataset and EEGWindowsDataset (continuous data).
-            With WindowsDataset (pre-cut epochs), each window is saved as a separate chunk.
+        chunk_size : int, default=5_000_000
+            Number of samples per chunk in Zarr along the time/window dimension.
+            Larger chunk sizes create fewer but larger chunks/files. This parameter
+            is used for both continuous data (e.g., RawDataset, EEGWindowsDataset)
+            and pre-cut windows (WindowsDataset). For WindowsDataset, multiple
+            windows may be stored in a single chunk depending on their duration
+            and the chosen ``chunk_size``.
         local_cache_dir : str | Path | None
             Local directory to use for temporary files during upload. If None, uses
             the system temp directory and cleans it up after upload. If provided,
@@ -657,7 +660,7 @@ class HubDatasetMixin:
         output_path: Path,
         compression: str,
         compression_level: int,
-        chunk_size: int = 10000,
+        chunk_size: int = 5_000_000,
     ) -> None:
         """Convert dataset to Zarr format (inline implementation)."""
 
@@ -723,7 +726,14 @@ class HubDatasetMixin:
 
                 # Save using inlined function
                 _save_windows_to_zarr(
-                    grp, data, metadata, description, info_dict, compressor, target_name
+                    grp,
+                    data,
+                    metadata,
+                    description,
+                    info_dict,
+                    compressor,
+                    target_name,
+                    chunk_size,
                 )
 
             elif dataset_type == "EEGWindowsDataset":
@@ -835,11 +845,16 @@ class HubDatasetMixin:
 
                 # Convert to MNE objects and create dataset
                 info = Info.from_json_dict(info_dict)
+                targets = metadata["target"].values
+                if np.issubdtype(targets.dtype, np.integer):
+                    event_ids = targets
+                else:
+                    event_ids = np.ones(len(metadata), dtype=int)
                 events = np.column_stack(
                     [
-                        metadata["i_start_in_trial"].values,
+                        metadata["i_start_in_trial"].values.astype(int),
                         np.zeros(len(metadata), dtype=int),
-                        metadata["target"].values,
+                        event_ids,
                     ]
                 )
                 epochs = mne.EpochsArray(data, info, events=events, metadata=metadata)

{braindecode-1.3.2.dev182822510 → braindecode-1.3.2.dev183191339}/braindecode/datasets/bids/hub_io.py

@@ -45,16 +45,25 @@ def _restore_nan_from_json(obj):
 
 
 def _save_windows_to_zarr(
-    grp, data, metadata, description, info, compressor, target_name
+    grp, data, metadata, description, info, compressor, target_name, chunk_size
 ):
     """Save windowed data to Zarr group (low-level function)."""
     data_array = data.astype(np.float32)
     compressors_list = [compressor] if compressor is not None else None
 
+    max_windows_per_chunk = max(
+        1, chunk_size // (data_array.shape[1] * data_array.shape[2])
+    )
+    n_windows_per_chunk = min(data_array.shape[0], max_windows_per_chunk)
+
     grp.create_array(
         "data",
         data=data_array,
-        chunks=(1, data_array.shape[1], data_array.shape[2]),
+        chunks=(
+            n_windows_per_chunk,
+            data_array.shape[1],
+            data_array.shape[2],
+        ),
         compressors=compressors_list,
     )
 
@@ -85,10 +94,13 @@ def _save_eegwindows_to_zarr(
     continuous_float = continuous_data.astype(np.float32)
     compressors_list = [compressor] if compressor is not None else None
 
+    max_samples_per_chunk = max(1, chunk_size // continuous_float.shape[0])
+    n_samples_per_chunk = min(continuous_float.shape[1], max_samples_per_chunk)
+
     grp.create_array(
         "data",
         data=continuous_float,
-        chunks=(continuous_float.shape[0], min(chunk_size, continuous_float.shape[1])),
+        chunks=(continuous_float.shape[0], n_samples_per_chunk),
         compressors=compressors_list,
     )
 
@@ -157,10 +169,13 @@ def _save_raw_to_zarr(grp, raw, description, info, target_name, compressor, chun
     continuous_float = continuous_data.astype(np.float32)
     compressors_list = [compressor] if compressor is not None else None
 
+    max_samples_per_chunk = max(1, chunk_size // continuous_float.shape[0])
+    n_samples_per_chunk = min(continuous_float.shape[1], max_samples_per_chunk)
+
     grp.create_array(
         "data",
         data=continuous_float,
-        chunks=(continuous_float.shape[0], min(chunk_size, continuous_float.shape[1])),
+        chunks=(continuous_float.shape[0], n_samples_per_chunk),
         compressors=compressors_list,
     )
 

{braindecode-1.3.2.dev182822510 → braindecode-1.3.2.dev183191339}/braindecode/datautil/hub_formats.py

@@ -36,7 +36,7 @@ def convert_to_zarr(
     output_path: Union[str, Path],
     compression: str = "blosc",
     compression_level: int = 5,
-    chunk_size: int = 10000,
+    chunk_size: int = 5_000_000,
     overwrite: bool = False,
 ) -> Path:
     """Convert BaseConcatDataset to Zarr format.
@@ -59,10 +59,13 @@ def convert_to_zarr(
         blosc uses zstd codec by default, providing best balance of speed and compression.
     compression_level : int, default=5
         Compression level (0-9). Level 5 provides optimal balance based on benchmarks.
-    chunk_size : int, default=10000
-        Number of samples per chunk in Zarr. Larger chunk size will create fewer
-        but larger files. Only used for RawDataset and EEGWindowsDataset (continuous data).
-        With WindowsDataset (pre-cut epochs), each window is saved as a separate chunk.
+    chunk_size : int, default=5_000_000
+        Target chunk size for Zarr storage.
+        For continuous data (e.g., RawDataset, EEGWindowsDataset), this is interpreted
+        as the approximate number of samples per chunk; larger values create fewer but
+        larger chunks on disk.
+        For pre-cut windowed data (WindowsDataset), this controls how many windows are
+        grouped together in each chunk (i.e., multiple windows can be stored per chunk).
     overwrite : bool, default=False
         Whether to overwrite existing directory.
 
@@ -74,8 +77,11 @@ def convert_to_zarr(
     Notes
     -----
     The chunking strategy is optimized for random access:
-    - Windowed data: Each window is a separate chunk (1, n_channels, n_times)
-    - Raw data: Chunks of (n_channels, 10000) samples
+    - Windowed data: Windows are stored in chunks of shape
+      (n_windows_in_chunk, n_channels, n_times), where n_windows_in_chunk is
+      determined by ``chunk_size``.
+    - Raw / continuous data: Time is split into chunks of approximately
+      ``chunk_size`` samples (per channel), e.g., (n_channels, n_times_per_chunk).
 
     Examples
     --------

{braindecode-1.3.2.dev182822510 → braindecode-1.3.2.dev183191339}/braindecode/models/__init__.py

@@ -12,6 +12,7 @@ from .contrawr import ContraWR
 from .ctnet import CTNet
 from .deep4 import Deep4Net
 from .deepsleepnet import DeepSleepNet
+from .dgcnn import DGCNN
 from .eegconformer import EEGConformer
 from .eeginception_erp import EEGInceptionERP
 from .eeginception_mi import EEGInceptionMI
@@ -54,6 +55,7 @@ from .tsinception import TSception
 from .usleep import USleep
 from .util import (
     _init_models_dict,
+    build_model_config,
     extract_channel_locations_from_chs_info,
     models_mandatory_parameters,
 )
@@ -87,6 +89,7 @@ __all__ = [
     "EEGSym",
     "EEGSimpleConv",
     "EEGTCNet",
+    "DGCNN",
     "FBCNet",
     "FBLightConvNet",
     "FBMSNet",
@@ -116,6 +119,7 @@ __all__ = [
     "TIDNet",
     "TSception",
     "USleep",
+    "build_model_config",
     "_init_models_dict",
     "models_mandatory_parameters",
 ]