braindecode 1.3.0.dev177069446__py3-none-any.whl → 1.3.0.dev177628147__py3-none-any.whl

braindecode/modules/attention.py

@@ -35,16 +35,6 @@ class SqueezeAndExcitation(nn.Module):
     bias: bool, default=False
         if True, adds a learnable bias will be used in the convolution.
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import SqueezeAndExcitation
-    >>> module = SqueezeAndExcitation(in_channels=16, reduction_rate=4)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Hu2018] Hu, J., Albanie, S., Sun, G., Wu, E., 2018.
@@ -100,16 +90,6 @@ class GSoP(nn.Module):
     bias: bool, default=False
         if True, adds a learnable bias will be used in the convolution.
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import GSoP
-    >>> module = GSoP(in_channels=16, reduction_rate=4)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Gao2018] Gao, Z., Jiangtao, X., Wang, Q., Li, P., 2018.
@@ -166,16 +146,6 @@ class FCA(nn.Module):
     reduction_rate : int, default=4
         Reduction ratio of the fully-connected layers.
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import FCA
-    >>> module = FCA(in_channels=16, seq_len=64, reduction_rate=4, freq_idx=0)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Qin2021] Qin, Z., Zhang, P., Wu, F., Li, X., 2021.
@@ -260,16 +230,6 @@ class EncNet(nn.Module):
     n_codewords : int
         number of codewords
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import EncNet
-    >>> module = EncNet(in_channels=16, n_codewords=8)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Zhang2018] Zhang, H. et al. 2018.
@@ -327,16 +287,6 @@ class ECA(nn.Module):
         kernel size of convolutional layer, determines degree of channel
         interaction, must be odd.
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import ECA
-    >>> module = ECA(in_channels=16, kernel_size=3)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Wang2021] Wang, Q. et al., 2021. ECA-Net: Efficient Channel Attention
@@ -388,16 +338,6 @@ class GatherExcite(nn.Module):
     reduction_rate : int, default=4
         reduction ratio of the excite block (if used)
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import GatherExcite
-    >>> module = GatherExcite(in_channels=16, seq_len=64, extra_params=False, use_mlp=True)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Hu2018b] Hu, J., Albanie, S., Sun, G., Vedaldi, A., 2018.
@@ -467,16 +407,6 @@ class GCT(nn.Module):
     in_channels : int
         number of input feature channels
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import GCT
-    >>> module = GCT(in_channels=16)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Yang2020] Yang, Z. Linchao, Z., Wu, Y., Yang, Y., 2020.
@@ -522,16 +452,6 @@ class SRM(nn.Module):
     reduction_rate : int, default=4
         reduction ratio of the fully-connected layers (if used),
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import SRM
-    >>> module = SRM(in_channels=16, use_mlp=False)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Lee2019] Lee, H., Kim, H., Nam, H., 2019. SRM: A Style-based
@@ -597,16 +517,6 @@ class CBAM(nn.Module):
     kernel_size : int
         kernel size of the convolutional layer
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import CBAM
-    >>> module = CBAM(in_channels=16, reduction_rate=4, kernel_size=3)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Woo2018] Woo, S., Park, J., Lee, J., Kweon, I., 2018.
@@ -665,16 +575,6 @@ class CAT(nn.Module):
     bias : bool, default=False
         if True, adds a learnable bias will be used in the convolution,
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import CAT
-    >>> module = CAT(in_channels=16, reduction_rate=4, kernel_size=3)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Wu2023] Wu, Z. et al., 2023
@@ -771,16 +671,6 @@ class CATLite(nn.Module):
     bias : bool, default=True
         if True, adds a learnable bias will be used in the convolution,
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import CATLite
-    >>> module = CATLite(in_channels=16, reduction_rate=4)
-    >>> inputs = torch.randn(2, 16, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 16, 1, 64])
-
     References
     ----------
     .. [Wu2023] Wu, Z. et al., 2023 CAT: Learning to Collaborate Channel and
@@ -834,19 +724,6 @@ class CATLite(nn.Module):
 
 
 class MultiHeadAttention(nn.Module):
-    """Multi-head self-attention block.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import MultiHeadAttention
-    >>> module = MultiHeadAttention(emb_size=32, num_heads=4, dropout=0.1)
-    >>> inputs = torch.randn(2, 10, 32)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 10, 32])
-    """
-
     def __init__(self, emb_size, num_heads, dropout):
         super().__init__()
         self.emb_size = emb_size

braindecode/modules/blocks.py

@@ -14,22 +14,6 @@ class InceptionBlock(nn.Module):
     ----------
     branches : list of nn.Module
         List of convolutional branches to apply to the input.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from torch import nn
-    >>> from braindecode.modules import InceptionBlock
-    >>> block = InceptionBlock(
-    ...     [
-    ...         nn.Conv1d(3, 4, kernel_size=1),
-    ...         nn.Conv1d(3, 4, kernel_size=3, padding=1),
-    ...     ]
-    ... )
-    >>> inputs = torch.randn(2, 3, 100)
-    >>> outputs = block(inputs)
-    >>> outputs.shape
-    torch.Size([2, 8, 100])
     """
 
     def __init__(self, branches):
@@ -71,16 +55,6 @@ class MLP(nn.Sequential):
         Dropout rate.
     normalize: bool (default=False)
         Whether to apply layer normalization.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import MLP
-    >>> module = MLP(in_features=32, hidden_features=(64,), out_features=16)
-    >>> inputs = torch.randn(2, 10, 32)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 10, 16])
     """
 
     def __init__(
@@ -125,33 +99,7 @@ class MLP(nn.Sequential):
 
 
 class FeedForwardBlock(nn.Sequential):
-    """Feedforward network block.
-
-    Parameters
-    ----------
-    emb_size : int
-        Embedding dimension.
-    expansion : int
-        Expansion factor for the hidden layer size.
-    drop_p : float
-        Dropout probability.
-    activation : type[nn.Module], default=nn.GELU
-        Activation function constructor.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import FeedForwardBlock
-    >>> module = FeedForwardBlock(emb_size=32, expansion=2, drop_p=0.1)
-    >>> inputs = torch.randn(2, 10, 32)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 10, 32])
-    """
-
-    def __init__(
-        self, emb_size, expansion, drop_p, activation: type[nn.Module] = nn.GELU
-    ):
+    def __init__(self, emb_size, expansion, drop_p, activation: nn.Module = nn.GELU):
         super().__init__(
             nn.Linear(emb_size, expansion * emb_size),
             activation(),

braindecode/modules/convolution.py

@@ -25,16 +25,6 @@ class AvgPool2dWithConv(nn.Module):
         Dilation applied to the pooling filter.
     padding: int or (int,int)
         Padding applied before the pooling operation.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import AvgPool2dWithConv
-    >>> module = AvgPool2dWithConv(kernel_size=(1, 4), stride=(1, 4))
-    >>> inputs = torch.randn(2, 4, 1, 16)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 4, 1, 4])
     """
 
     def __init__(self, kernel_size, stride, dilation=1, padding=0):
@@ -83,19 +73,6 @@ class AvgPool2dWithConv(nn.Module):
 
 
 class Conv2dWithConstraint(nn.Conv2d):
-    """2D convolution with max-norm constraint on the weights.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import Conv2dWithConstraint
-    >>> module = Conv2dWithConstraint(4, 8, kernel_size=(1, 3), padding=(0, 1), bias=False)
-    >>> inputs = torch.randn(2, 4, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 8, 1, 64])
-    """
-
     def __init__(self, *args, max_norm=1, **kwargs):
         super().__init__(*args, **kwargs)
         self.max_norm = max_norm
@@ -124,16 +101,6 @@ class CombinedConv(nn.Module):
     bias_spat: bool
         Whether to use bias in the spatial conv
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import CombinedConv
-    >>> module = CombinedConv(in_chans=8, n_filters_time=4, n_filters_spat=4, filter_time_length=5)
-    >>> inputs = torch.randn(2, 1, 100, 8)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 4, 96, 1])
-
     """
 
     def __init__(
@@ -215,16 +182,6 @@ class CausalConv1d(nn.Conv1d):
     ----------
     .. [1] https://discuss.pytorch.org/t/causal-convolution/3456/4
     .. [2] https://gist.github.com/paultsw/7a9d6e3ce7b70e9e2c61bc9287addefc
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import CausalConv1d
-    >>> module = CausalConv1d(in_channels=4, out_channels=8, kernel_size=5, dilation=2)
-    >>> inputs = torch.randn(2, 4, 128)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 8, 128])
     """
 
     def __init__(
@@ -293,16 +250,6 @@ class DepthwiseConv2d(torch.nn.Conv2d):
         Padding mode to use. Options are 'zeros', 'reflect', 'replicate', or
         'circular'.
         Default is 'zeros'.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import DepthwiseConv2d
-    >>> module = DepthwiseConv2d(in_channels=4, depth_multiplier=2, kernel_size=3, padding=1)
-    >>> inputs = torch.randn(2, 4, 1, 64)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 8, 1, 64])
     """
 
     def __init__(

braindecode/modules/filter.py

@@ -113,22 +113,6 @@ class FilterBankLayer(nn.Module):
         Control verbosity of the logging output. If ``None``, use the default
         verbosity level. See the func:`mne.verbose` for details.
         Should only be passed as a keyword argument.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import FilterBankLayer
-    >>> module = FilterBankLayer(
-    ...     n_chans=2,
-    ...     sfreq=128,
-    ...     band_filters=[(4.0, 8.0), (8.0, 12.0)],
-    ...     method="fir",
-    ...     verbose=False,
-    ... )
-    >>> inputs = torch.randn(2, 2, 256)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 2, 2, 256])
     """
 
     def __init__(
@@ -417,21 +401,6 @@ class GeneralizedGaussianFilter(nn.Module):
         Minimum and maximum allowable values for the center frequency `f_mean` in Hz.
         Specified as (min_f_mean, max_f_mean). Default is (1.0, 45.0).
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import GeneralizedGaussianFilter
-    >>> module = GeneralizedGaussianFilter(
-    ...     in_channels=2,
-    ...     out_channels=2,
-    ...     sequence_length=256,
-    ...     sample_rate=128,
-    ...     inverse_fourier=True,
-    ... )
-    >>> inputs = torch.randn(3, 2, 256)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([3, 2, 256])
 
     Notes
     -----

braindecode/modules/layers.py

@@ -11,21 +11,6 @@ from braindecode.functional import drop_path
 
 
 class Ensure4d(nn.Module):
-    """Ensure the input tensor has 4 dimensions.
-
-    This is a small utility layer that repeatedly adds a singleton dimension at
-    the end until the input has shape ``(batch, channels, time, 1)``.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import Ensure4d
-    >>> module = Ensure4d()
-    >>> outputs = module(torch.randn(2, 3, 10))
-    >>> outputs.shape
-    torch.Size([2, 3, 10, 1])
-    """
-
     def forward(self, x):
         while len(x.shape) < 4:
             x = x.unsqueeze(-1)
@@ -33,19 +18,6 @@ class Ensure4d(nn.Module):
 
 
 class Chomp1d(nn.Module):
-    """Remove samples from the end of a sequence.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import Chomp1d
-    >>> module = Chomp1d(chomp_size=5)
-    >>> inputs = torch.randn(2, 3, 20)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 3, 15])
-    """
-
     def __init__(self, chomp_size):
         super().__init__()
         self.chomp_size = chomp_size
@@ -71,17 +43,6 @@ class TimeDistributed(nn.Module):
     module : nn.Module
         Module to be applied to the input windows. Must accept an input of
         shape (batch_size, n_channels, n_times).
-
-    Examples
-    --------
-    >>> import torch
-    >>> from torch import nn
-    >>> from braindecode.modules import TimeDistributed
-    >>> module = TimeDistributed(nn.Conv1d(3, 4, kernel_size=3, padding=1))
-    >>> inputs = torch.randn(2, 5, 3, 20)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 5, 4])
     """
 
     def __init__(self, module):
@@ -130,17 +91,6 @@ class DropPath(nn.Module):
     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     SOFTWARE.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import DropPath
-    >>> module = DropPath(drop_prob=0.2)
-    >>> module.train()
-    >>> inputs = torch.randn(2, 3, 10)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 3, 10])
     """
 
     def __init__(self, drop_prob=None):
@@ -180,37 +130,3 @@ class SqueezeFinalOutput(nn.Module):
         if x.shape[-1] == 1:
             x = x.squeeze(-1)
         return x
-
-
-class SubjectLayers(nn.Module):
-    """Per-subject linear transformation layer.
-
-    Applies subject-specific linear transformations to the input. Each subject
-    owns an independent weight matrix, enabling personalized feature
-    processing.
-    """
-
-    def __init__(
-        self,
-        in_channels: int,
-        out_channels: int,
-        n_subjects: int,
-        init_id: bool = False,
-    ):
-        super().__init__()
-        self.weights = nn.Parameter(torch.randn(n_subjects, in_channels, out_channels))
-        if init_id:
-            if in_channels != out_channels:
-                raise AssertionError("init_id requires in_channels == out_channels")
-            self.weights.data[:] = torch.eye(in_channels)[None]
-        self.weights.data *= 1 / (in_channels**0.5)
-
-    def forward(self, x: torch.Tensor, subjects: torch.Tensor) -> torch.Tensor:
-        """Apply the subject-specific linear transforms."""
-        _, C, D = self.weights.shape
-        weights = self.weights.gather(0, subjects.view(-1, 1, 1).expand(-1, C, D))
-        return torch.einsum("bct,bcd->bdt", x, weights)
-
-    def __repr__(self) -> str:
-        S, C, D = self.weights.shape
-        return f"SubjectLayers({C}, {D}, {S})"

braindecode/modules/linear.py

@@ -20,16 +20,6 @@ class MaxNormLinear(nn.Linear):
         If set to ``False``, the layer will not learn an additive bias.
         Default: ``True``.
 
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import MaxNormLinear
-    >>> module = MaxNormLinear(10, 5, max_norm_val=2)
-    >>> inputs = torch.randn(2, 10)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 5])
-
     References
     ----------
     .. [1] https://keras.io/api/layers/core_layers/dense/#dense-class
@@ -51,18 +41,7 @@ class MaxNormLinear(nn.Linear):
 
 
 class LinearWithConstraint(nn.Linear):
-    """Linear layer with max-norm constraint on the weights.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import LinearWithConstraint
-    >>> module = LinearWithConstraint(10, 5, max_norm=1.0)
-    >>> inputs = torch.randn(2, 10)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 5])
-    """
+    """Linear layer with max-norm constraint on the weights."""
 
     def __init__(self, *args, max_norm=1.0, **kwargs):
         super(LinearWithConstraint, self).__init__(*args, **kwargs)

braindecode/modules/stats.py

@@ -22,16 +22,6 @@ class StatLayer(nn.Module):
         Used only for functions requiring clamping (e.g., log variance).
     apply_log : bool, default=False
         Whether to apply log after computation (used for LogVarLayer).
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import StatLayer
-    >>> module = StatLayer(stat_fn=torch.mean, dim=-1, keepdim=True)
-    >>> inputs = torch.randn(2, 3, 10)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 3, 1])
     """
 
     def __init__(

braindecode/modules/util.py

@@ -71,15 +71,6 @@ def aggregate_probas(logits, n_windows_stride=1):
         De Vos, M. (2018). Joint classification and prediction CNN framework
         for automatic sleep stage classification. IEEE Transactions on
         Biomedical Engineering, 66(5), 1285-1296.
-
-    Examples
-    --------
-    >>> import numpy as np
-    >>> from braindecode.modules import aggregate_probas
-    >>> logits = np.random.randn(3, 4, 5)  # (n_sequences, n_classes, n_windows)
-    >>> probas = aggregate_probas(logits, n_windows_stride=1)
-    >>> probas.shape
-    (7, 4)
     """
     log_probas = log_softmax(logits, axis=1)
     return _pad_shift_array(log_probas, stride=n_windows_stride).sum(axis=0).T

braindecode/modules/wrapper.py

@@ -10,16 +10,6 @@ class Expression(nn.Module):
     expression_fn : callable
         Should accept variable number of objects of type
         `torch.autograd.Variable` to compute its output.
-
-    Examples
-    --------
-    >>> import torch
-    >>> from braindecode.modules import Expression
-    >>> module = Expression(lambda x: x**2)
-    >>> inputs = torch.randn(2, 3)
-    >>> outputs = module(inputs)
-    >>> outputs.shape
-    torch.Size([2, 3])
     """
 
     def __init__(self, expression_fn):
@@ -59,13 +49,6 @@ class IntermediateOutputWrapper(nn.Module):
     >>> model = Deep4Net()
     >>> select_modules = ['conv_spat','conv_2','conv_3','conv_4'] # Specify intermediate outputs
     >>> model_pert = IntermediateOutputWrapper(select_modules,model) # Wrap model
-
-    >>> import torch
-    >>> base = torch.nn.Sequential(torch.nn.Linear(10, 8), torch.nn.ReLU(), torch.nn.Linear(8, 2))
-    >>> wrapped = IntermediateOutputWrapper(to_select=["0", "2"], model=base)
-    >>> outputs = wrapped(torch.randn(4, 10))
-    >>> len(outputs)
-    2
     """
 
     def __init__(self, to_select, model):

braindecode/preprocessing/preprocess.py

@@ -324,9 +324,6 @@ def _replace_inplace(concat_ds, new_concat_ds):
             concat_ds, preproc_kwargs_attr, getattr(new_concat_ds, preproc_kwargs_attr)
         )
 
-    # Recompute cumulative_sizes after replacing datasets
-    concat_ds.cumulative_sizes = concat_ds.cumsum(concat_ds.datasets)
-
 
 def _preprocess(
     ds: RecordDataset,