Braindecode 1.3.0.dev177147151__tar.gz → 1.3.0.dev177551367__tar.gz

{braindecode-1.3.0.dev177147151/braindecode.egg-info → braindecode-1.3.0.dev177551367}/PKG-INFO

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

{braindecode-1.3.0.dev177147151 → braindecode-1.3.0.dev177551367}/braindecode/datasets/base.py

@@ -19,7 +19,7 @@ import warnings
 from abc import abstractmethod
 from collections.abc import Callable
 from glob import glob
-from typing import Any, Generic, Iterable, no_type_check
+from typing import Generic, Iterable, no_type_check
 
 import mne.io
 import numpy as np
@@ -129,7 +129,6 @@ class RawDataset(RecordDataset):
 
         # save target name for load/save later
         self.target_name = self._target_name(target_name)
-        self.raw_preproc_kwargs: list[dict[str, Any]] = []
 
     def __getitem__(self, index):
         X = self.raw[:, index][0]
@@ -236,7 +235,6 @@ class EEGWindowsDataset(RecordDataset):
         ].to_numpy()
         if self.targets_from == "metadata":
             self.y = metadata.loc[:, "target"].to_list()
-        self.raw_preproc_kwargs: list[dict[str, Any]] = []
 
     def __getitem__(self, index: int):
         """Get a window and its target.
@@ -336,8 +334,6 @@ class WindowsDataset(RecordDataset):
         ].to_numpy()
         if self.targets_from == "metadata":
             self.y = metadata.loc[:, "target"].to_list()
-        self.raw_preproc_kwargs: list[dict[str, Any]] = []
-        self.window_preproc_kwargs: list[dict[str, Any]] = []
 
     def __getitem__(self, index: int):
         """Get a window and its target.
@@ -798,7 +794,7 @@ class BaseConcatDataset(ConcatDataset, Generic[T]):
                 kwargs = getattr(ds, kwargs_name)
                 if kwargs is not None:
                     with open(kwargs_file_path, "w") as f:
-                        json.dump(kwargs, f, indent=2)
+                        json.dump(kwargs, f)
 
     @staticmethod
     def _save_target_name(sub_dir, ds):

{braindecode-1.3.0.dev177147151 → braindecode-1.3.0.dev177551367}/braindecode/datautil/serialization.py

@@ -302,6 +302,7 @@ def _load_kwargs_json(kwargs_name, sub_dir):
     kwargs_file_path = os.path.join(sub_dir, kwargs_file_name)
     if os.path.exists(kwargs_file_path):
         kwargs = json.load(open(kwargs_file_path, "r"))
+        kwargs = [tuple(kwarg) for kwarg in kwargs]
         return kwargs
 
 

{braindecode-1.3.0.dev177147151 → braindecode-1.3.0.dev177551367}/braindecode/models/__init__.py

@@ -28,7 +28,6 @@ from .fbmsnet import FBMSNet
 from .hybrid import HybridNet
 from .ifnet import IFNet
 from .labram import Labram
-from .medformer import MEDFormer
 from .msvtnet import MSVTNet
 from .patchedtransformer import PBT
 from .sccnet import SCCNet
@@ -83,7 +82,6 @@ __all__ = [
     "HybridNet",
     "IFNet",
     "Labram",
-    "MEDFormer",
     "MSVTNet",
     "PBT",
     "SCCNet",

{braindecode-1.3.0.dev177147151 → braindecode-1.3.0.dev177551367}/braindecode/models/summary.csv

@@ -41,4 +41,3 @@ IFNet,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times, sfreq",9860
 PBT,General,Classification,250,"n_chans, n_outputs, n_times",818948,"PBT(n_chans=22, n_outputs=4, n_times=1000, sfreq=250)","Large Brain Model"
 SSTDPN,Motor Imagery,Classification,250,"n_chans, n_outputs, n_times",19502,"SSTDPN(n_chans=22, n_outputs=4, n_times=1000)","Convolution,Small Attention"
 BENDR,General,"Classification,Embedding",250,"n_chans, n_times, n_outputs",157141049,"BENDR(n_chans=22, n_outputs=4, n_times=1000)","Large Brain Model,Convolution"
-MEDFormer,General,Classification,250,"n_chans, n_outputs, n_times",5313924,"MEDFormer(n_chans=22, n_outputs=4, n_times=1000)","Large Brain Model,Convolution"

{braindecode-1.3.0.dev177147151 → braindecode-1.3.0.dev177551367}/braindecode/models/util.py

@@ -99,7 +99,6 @@ models_mandatory_parameters = [
     ("PBT", ["n_chans", "n_outputs", "n_times"], None),
     ("SSTDPN", ["n_chans", "n_outputs", "n_times", "sfreq"], None),
     ("BENDR", ["n_chans", "n_outputs", "n_times"], None),
-    ("MEDFormer", ["n_chans", "n_outputs", "n_times"], None),
 ]
 
 ################################################################

{braindecode-1.3.0.dev177147151 → braindecode-1.3.0.dev177551367}/braindecode/preprocessing/__init__.py

@@ -188,17 +188,12 @@ from .preprocess import (
     filterbank,
     preprocess,
 )
-from .util import _init_preprocessor_dict
 from .windowers import (
     create_fixed_length_windows,
     create_windows_from_events,
     create_windows_from_target_channels,
 )
 
-# Call this last in order to make sure the list is populated with
-# the preprocessors imported in this file.
-_init_preprocessor_dict()
-
 __all__ = [
     "exponential_moving_demean",
     "exponential_moving_standardize",

{braindecode-1.3.0.dev177147151 → braindecode-1.3.0.dev177551367}/braindecode/preprocessing/eegprep_preprocess.py

@@ -77,14 +77,6 @@ class EEGPrepBasePreprocessor(Preprocessor):
         self.record_orig_chanlocs = record_orig_chanlocs
         self.force_dtype = np.dtype(force_dtype) if force_dtype is not None else None
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "can_change_duration",
-            "record_orig_chanlocs",
-            "force_dtype",
-        ]
-
     @abstractmethod
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure. Overridden by subclass."""
@@ -388,46 +380,31 @@ class EEGPrep(EEGPrepBasePreprocessor):
             can_change_duration=can_change_duration or False,
         )
         self.resample_to = resample_to
-        self.bad_channel_reinterpolate = bad_channel_reinterpolate
+        self.reinterpolate = bad_channel_reinterpolate
         self.common_avg_ref = common_avg_ref
         self.burst_removal_cutoff = burst_removal_cutoff
         self.bad_window_max_bad_channels = bad_window_max_bad_channels
-        self.bad_channel_corr_threshold = bad_channel_corr_threshold
-        self.highpass_frequencies = highpass_frequencies
-        self.flatline_maxdur = flatline_maxdur
-        self.bad_channel_hf_threshold = bad_channel_hf_threshold
-        self.bad_channel_max_broken_time = bad_channel_max_broken_time
-        self.bad_window_tolerances = bad_window_tolerances
-        self.refdata_max_bad_channels = refdata_max_bad_channels
-        self.refdata_max_tolerances = refdata_max_tolerances
-        self.num_samples = num_samples
-        self.subset_size = subset_size
-        self.bad_channel_nolocs_threshold = bad_channel_nolocs_threshold
-        self.bad_channel_nolocs_exclude_frac = bad_channel_nolocs_exclude_frac
-        self.max_mem_mb = max_mem_mb
 
-    @property
-    def clean_artifacts_params(self):
-        if self.bad_channel_corr_threshold is None:
+        if bad_channel_corr_threshold is None:
             line_noise_crit = None
         else:
-            line_noise_crit = self.bad_channel_hf_threshold
-        return dict(
-            ChannelCriterion=self.bad_channel_corr_threshold,
+            line_noise_crit = bad_channel_hf_threshold
+        self.clean_artifacts_params = dict(
+            ChannelCriterion=bad_channel_corr_threshold,
             LineNoiseCriterion=line_noise_crit,
-            BurstCriterion=self.burst_removal_cutoff,
-            WindowCriterion=self.bad_window_max_bad_channels,
-            Highpass=self.highpass_frequencies,
-            ChannelCriterionMaxBadTime=self.bad_channel_max_broken_time,
-            BurstCriterionRefMaxBadChns=self.refdata_max_bad_channels,
-            BurstCriterionRefTolerances=self.refdata_max_tolerances,
-            WindowCriterionTolerances=self.bad_window_tolerances,
-            FlatlineCriterion=self.flatline_maxdur,
-            NumSamples=self.num_samples,
-            SubsetSize=self.subset_size,
-            NoLocsChannelCriterion=self.bad_channel_nolocs_threshold,
-            NoLocsChannelCriterionExcluded=self.bad_channel_nolocs_exclude_frac,
-            MaxMem=self.max_mem_mb,
+            BurstCriterion=burst_removal_cutoff,
+            WindowCriterion=bad_window_max_bad_channels,
+            Highpass=highpass_frequencies,
+            ChannelCriterionMaxBadTime=bad_channel_max_broken_time,
+            BurstCriterionRefMaxBadChns=refdata_max_bad_channels,
+            BurstCriterionRefTolerances=refdata_max_tolerances,
+            WindowCriterionTolerances=bad_window_tolerances,
+            FlatlineCriterion=flatline_maxdur,
+            NumSamples=num_samples,
+            SubsetSize=subset_size,
+            NoLocsChannelCriterion=bad_channel_nolocs_threshold,
+            NoLocsChannelCriterionExcluded=bad_channel_nolocs_exclude_frac,
+            MaxMem=max_mem_mb,
             # For reference, the function additionally accepts these (legacy etc.)
             # arguments, which we're not exposing here (current defaults as below):
             # BurstRejection='off',
@@ -437,29 +414,6 @@ class EEGPrep(EEGPrepBasePreprocessor):
             # availableRAM_GB=None,
         )
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "resample_to",
-            "bad_channel_reinterpolate",
-            "common_avg_ref",
-            "burst_removal_cutoff",
-            "bad_window_max_bad_channels",
-            "bad_channel_corr_threshold",
-            "highpass_frequencies",
-            "flatline_maxdur",
-            "bad_channel_hf_threshold",
-            "bad_channel_max_broken_time",
-            "bad_window_tolerances",
-            "refdata_max_bad_channels",
-            "refdata_max_tolerances",
-            "num_samples",
-            "subset_size",
-            "bad_channel_nolocs_threshold",
-            "bad_channel_nolocs_exclude_frac",
-            "max_mem_mb",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         # remove per-channel DC offset (can be huge)
@@ -495,9 +449,7 @@ class EEGPrep(EEGPrepBasePreprocessor):
             eeg["data"] = eeg["data"].astype(np.float32)
 
         # optionally reinterpolate dropped channels
-        if self.bad_channel_reinterpolate and (
-            len(orig_chanlocs) > len(eeg["chanlocs"])
-        ):
+        if self.reinterpolate and (len(orig_chanlocs) > len(eeg["chanlocs"])):
             eeg = eegprep.eeg_interp(eeg, orig_chanlocs)
 
         # optionally apply common average reference
@@ -561,13 +513,6 @@ class RemoveFlatChannels(EEGPrepBasePreprocessor):
         self.max_flatline_duration = max_flatline_duration
         self.max_allowed_jitter = max_allowed_jitter
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "max_flatline_duration",
-            "max_allowed_jitter",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg = eegprep.clean_flatlines(
@@ -664,14 +609,6 @@ class RemoveDrifts(EEGPrepBasePreprocessor):
         self.attenuation = attenuation
         self.method = method
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "transition",
-            "attenuation",
-            "method",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg = eegprep.clean_drifts(
@@ -738,10 +675,6 @@ class Resampling(EEGPrepBasePreprocessor):
         super().__init__(can_change_duration=True)
         self.sfreq = sfreq
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + ["sfreq"]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         if self.sfreq is not None:
@@ -846,17 +779,6 @@ class RemoveBadChannels(EEGPrepBasePreprocessor):
         self.num_samples = num_samples
         self.subset_size = subset_size
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "corr_threshold",
-            "noise_threshold",
-            "window_len",
-            "max_broken_time",
-            "num_samples",
-            "subset_size",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg = eegprep.clean_channels(
@@ -947,16 +869,6 @@ class RemoveBadChannelsNoLocs(EEGPrepBasePreprocessor):
         self.max_broken_time = max_broken_time
         self.linenoise_aware = linenoise_aware
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "min_corr",
-            "ignored_quantile",
-            "window_len",
-            "max_broken_time",
-            "linenoise_aware",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg, _ = eegprep.clean_channels_nolocs(
@@ -1070,19 +982,6 @@ class RemoveBursts(EEGPrepBasePreprocessor):
         self.ref_wndlen = ref_wndlen
         self.maxmem = maxmem
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "cutoff",
-            "window_len",
-            "step_size",
-            "max_dims",
-            "ref_maxbadchannels",
-            "ref_tolerances",
-            "ref_wndlen",
-            "maxmem",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg = eegprep.clean_asr(
@@ -1199,20 +1098,6 @@ class RemoveBadWindows(EEGPrepBasePreprocessor):
         self.step_sizes = step_sizes
         self.shape_range = shape_range
 
-    @property
-    def _all_attrs(self):
-        return super()._all_attrs + [
-            "max_bad_channels",
-            "zthresholds",
-            "window_len",
-            "window_overlap",
-            "max_dropout_fraction",
-            "min_clean_fraction",
-            "truncate_quant",
-            "step_sizes",
-            "shape_range",
-        ]
-
     def apply_eeg(self, eeg: dict[str, Any], raw: BaseRaw) -> dict[str, Any]:
         """Apply the preprocessor to an EEGLAB EEG structure."""
         eeg, _ = eegprep.clean_windows(

{braindecode-1.3.0.dev177147151 → braindecode-1.3.0.dev177551367}/braindecode/preprocessing/mne_preprocess.py

@@ -38,60 +38,24 @@ def _generate_init_method(func, force_copy_false=False):
     force_copy_false : bool
         If True, forces copy=False by default for functions that have a copy parameter.
     """
-    func_name = func.__name__
     parameters = list(inspect.signature(func).parameters.values())
-    param_names = [
-        param.name
-        for param in parameters[1:]  # Skip 'self' or 'raw' or 'epochs'
-    ]
-    all_mandatory = [
-        param.name
-        for param in parameters[1:]  # Skip 'self' or 'raw' or 'epochs'
-        if param.default == inspect.Parameter.empty
-    ]
+    param_names = [param.name for param in parameters]
 
     def init_method(self, *args, **kwargs):
-        used = []
-        mandatory = list(all_mandatory)
-        init_kwargs = {}
-
         # For standalone functions with copy parameter, set copy=False by default
         if force_copy_false and "copy" in param_names and "copy" not in kwargs:
             kwargs["copy"] = False
 
         for name, value in zip(param_names, args):
-            init_kwargs[name] = value
-            used.append(name)
-            if name in mandatory:
-                mandatory.remove(name)
+            setattr(self, name, value)
         for name, value in kwargs.items():
-            if name in used:
-                raise TypeError(f"Multiple values for argument '{name}'")
-            if name not in param_names:
-                raise TypeError(
-                    f"'{name}' is an invalid keyword argument for {func_name}()"
-                )
-            init_kwargs[name] = value
-            if name in mandatory:
-                mandatory.remove(name)
-        if len(mandatory) > 0:
-            raise TypeError(
-                f"{func_name}() missing required arguments: {', '.join(mandatory)}"
-            )
-        Preprocessor.__init__(self, fn=func_name, apply_on_array=False, **init_kwargs)
+            setattr(self, name, value)
+        self.kwargs = kwargs
 
     init_method.__signature__ = inspect.signature(func)
     return init_method
 
 
-def _generate_repr_method(class_name):
-    def repr_method(self):
-        args_str = ", ".join(f"{k}={v.__repr__()}" for k, v in self.kwargs.items())
-        return f"{class_name}({args_str})"
-
-    return repr_method
-
-
 def _generate_mne_pre_processor(function):
     """
     Generate a class based on an MNE function for preprocessing.
@@ -105,14 +69,10 @@ def _generate_mne_pre_processor(function):
     class_name = "".join(word.title() for word in function.__name__.split("_")).replace(
         "Eeg", "EEG"
     )
-
-    # Automatically determine if function is standalone
-    is_standalone = _is_standalone_function(function)
-
     # Create a wrapper note that references the original MNE function
     # For Raw methods, use mne.io.Raw.method_name format with :meth:
     # For standalone functions, use the function name only with :func:
-    if not is_standalone:
+    if hasattr(mne.io.Raw, function.__name__):
         ref_path = f"mne.io.Raw.{function.__name__}"
         ref_role = "meth"
     else:
@@ -136,10 +96,6 @@ def _generate_mne_pre_processor(function):
 
     base_classes = (Preprocessor,)
 
-    # Check if function has a 'copy' parameter
-    sig = inspect.signature(function)
-    has_copy_param = "copy" in sig.parameters
-    force_copy_false = is_standalone and has_copy_param
     # Automatically determine if function is standalone
     is_standalone = _is_standalone_function(function)
 
@@ -147,13 +103,26 @@ def _generate_mne_pre_processor(function):
     sig = inspect.signature(function)
     has_copy_param = "copy" in sig.parameters
     force_copy_false = is_standalone and has_copy_param
-    class_attrs = {
-        "__init__": _generate_init_method(function, force_copy_false),
-        "__doc__": wrapper_note + (function.__doc__ or ""),
-        "__repr__": _generate_repr_method(class_name),
-        "fn": function if is_standalone else function.__name__,
-        "_is_standalone": is_standalone,
-    }
+
+    if is_standalone:
+        # For standalone functions, store the actual function object
+        class_attrs = {
+            "__init__": _generate_init_method(
+                function, force_copy_false=force_copy_false
+            ),
+            "__doc__": wrapper_note + (function.__doc__ or ""),
+            "fn": function,  # Store the function itself, not the name
+            "_is_standalone": True,
+        }
+    else:
+        # For methods, store the function name as before
+        class_attrs = {
+            "__init__": _generate_init_method(function),
+            "__doc__": wrapper_note + (function.__doc__ or ""),
+            "fn": function.__name__,
+            "_is_standalone": False,
+        }
+
     generated_class = type(class_name, base_classes, class_attrs)
 
     return generated_class