Braindecode 1.3.2.dev182544824__tar.gz → 1.3.2.dev182822510__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: braindecode
-Version: 1.3.2.dev182544824
+Version: 1.3.2.dev182822510
 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.0
+Requires-Dist: torch>=2.2
 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: pydantic>=2.0
+Requires-Dist: pandas<3.0.0
 Provides-Extra: moabb
 Requires-Dist: moabb>=1.4.3; extra == "moabb"
 Provides-Extra: eegprep

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

@@ -579,89 +579,6 @@ 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):
@@ -815,9 +732,7 @@ class BaseConcatDataset(ConcatDataset, HubDatasetMixin, Generic[T]):
 
     def __init__(
         self,
-        list_of_ds: (
-            list[T] | list[BaseConcatDataset[T]] | list[T | BaseConcatDataset[T]]
-        ),
+        list_of_ds: list[T | BaseConcatDataset[T]],
         target_transform: Callable | None = None,
         *,
         lazy: bool = False,
@@ -1394,40 +1309,3 @@ 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.dev182544824 → braindecode-1.3.2.dev182822510}/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 = 5_000_000,
+        chunk_size: int = 10000,
         local_cache_dir: str | Path | None = None,
         **kwargs,
     ) -> str:
@@ -129,13 +129,10 @@ 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=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``.
+        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.
         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,
@@ -660,7 +657,7 @@ class HubDatasetMixin:
         output_path: Path,
         compression: str,
         compression_level: int,
-        chunk_size: int = 5_000_000,
+        chunk_size: int = 10000,
     ) -> None:
         """Convert dataset to Zarr format (inline implementation)."""
 
@@ -726,14 +723,7 @@ class HubDatasetMixin:
 
                 # Save using inlined function
                 _save_windows_to_zarr(
-                    grp,
-                    data,
-                    metadata,
-                    description,
-                    info_dict,
-                    compressor,
-                    target_name,
-                    chunk_size,
+                    grp, data, metadata, description, info_dict, compressor, target_name
                 )
 
             elif dataset_type == "EEGWindowsDataset":
@@ -845,16 +835,11 @@ 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.astype(int),
+                        metadata["i_start_in_trial"].values,
                         np.zeros(len(metadata), dtype=int),
-                        event_ids,
+                        metadata["target"].values,
                     ]
                 )
                 epochs = mne.EpochsArray(data, info, events=events, metadata=metadata)

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

@@ -45,25 +45,16 @@ def _restore_nan_from_json(obj):
 
 
 def _save_windows_to_zarr(
-    grp, data, metadata, description, info, compressor, target_name, chunk_size
+    grp, data, metadata, description, info, compressor, target_name
 ):
     """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=(
-            n_windows_per_chunk,
-            data_array.shape[1],
-            data_array.shape[2],
-        ),
+        chunks=(1, data_array.shape[1], data_array.shape[2]),
         compressors=compressors_list,
     )
 
@@ -94,13 +85,10 @@ 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], n_samples_per_chunk),
+        chunks=(continuous_float.shape[0], min(chunk_size, continuous_float.shape[1])),
         compressors=compressors_list,
     )
 
@@ -169,13 +157,10 @@ 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], n_samples_per_chunk),
+        chunks=(continuous_float.shape[0], min(chunk_size, continuous_float.shape[1])),
         compressors=compressors_list,
     )
 

{braindecode-1.3.2.dev182544824 → braindecode-1.3.2.dev182822510}/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 = 5_000_000,
+    chunk_size: int = 10000,
     overwrite: bool = False,
 ) -> Path:
     """Convert BaseConcatDataset to Zarr format.
@@ -59,13 +59,10 @@ 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=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).
+    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.
     overwrite : bool, default=False
         Whether to overwrite existing directory.
 
@@ -77,11 +74,8 @@ def convert_to_zarr(
     Notes
     -----
     The chunking strategy is optimized for random access:
-    - 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).
+    - Windowed data: Each window is a separate chunk (1, n_channels, n_times)
+    - Raw data: Chunks of (n_channels, 10000) samples
 
     Examples
     --------

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

@@ -12,7 +12,6 @@ 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
@@ -55,7 +54,6 @@ 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,
 )
@@ -89,7 +87,6 @@ __all__ = [
     "EEGSym",
     "EEGSimpleConv",
     "EEGTCNet",
-    "DGCNN",
     "FBCNet",
     "FBLightConvNet",
     "FBMSNet",
@@ -119,7 +116,6 @@ __all__ = [
     "TIDNet",
     "TSception",
     "USleep",
-    "build_model_config",
     "_init_models_dict",
     "models_mandatory_parameters",
 ]