Added tests for residual block and fixed bugs for it.

Author: renierts

src/faith/__init__.py

@@ -1 +0,0 @@
-from . import core

src/faith/train/blocks/__init__.py

@@ -3,14 +3,14 @@
 from .residual import ResidualBlock
 from .encoder import EncoderBlock, BlockBasedEncoder
 from .decoder import DecoderBlock, BlockBasedDecoder
-from .base import BaseBlock, BlockUtils
+from .base import BaseConvBlock, BlockUtils
 
 __all__ = [
     "ResidualBlock",
     "EncoderBlock",
     "BlockBasedEncoder",
     "DecoderBlock",
     "BlockBasedDecoder",
-    "BaseBlock",
+    "BaseConvBlock",
     "BlockUtils",
 ]

src/faith/train/blocks/base.py

@@ -13,8 +13,8 @@
 import math
 
 
-class BaseBlock(nn.Module, ABC):
-    """Abstract base class for all neural network blocks.
+class BaseConvBlock(nn.Module, ABC):
+    """Abstract base class for all convolutional-based neural network blocks.
 
     This class defines the common interface that all blocks should implement,
     ensuring consistency across different block types in the autoencoder
@@ -60,6 +60,21 @@ def __init__(
             raise ValueError(
                 f"out_channels must be positive, got {out_channels}")
 
+        if not isinstance(in_channels, int):
+            raise TypeError(
+                f"in_channels must be an int, got {type(in_channels)}")
+
+        if not isinstance(out_channels, int):
+            raise TypeError(
+                f"out_channels must be an int, got {type(out_channels)}")
+
+        if isinstance(kernel_size, int) and kernel_size <= 0:
+            raise ValueError(
+                f"kernel_size must be positive, got {kernel_size}")
+        if isinstance(kernel_size, tuple) and any(k <= 0 for k in kernel_size):
+            raise ValueError(
+                f"kernel_size must be positive, got {kernel_size}")
+
         self.in_channels = in_channels
         self.out_channels = out_channels
         self.kernel_size = self._normalize_kernel_size(kernel_size)
@@ -82,11 +97,11 @@ def _calculate_padding(
         """Calculate padding based on kernel size and padding specification."""
         if padding == 'auto':
             if isinstance(kernel_size, int):
-                return (kernel_size // 2, kernel_size // 2)
+                return kernel_size // 2, kernel_size // 2
             else:
                 return tuple(k // 2 for k in kernel_size)
         elif isinstance(padding, int):
-            return (padding, padding)
+            return padding, padding
         else:
             return padding
 
@@ -140,7 +155,7 @@ def __repr__(self) -> str:
                 f"bias={self.bias})")
 
 
-class SequentialBlock(BaseBlock):
+class SequentialBlock(BaseConvBlock):
     """Base class for blocks that apply operations sequentially.
 
     This class provides common functionality for blocks that consist of
@@ -181,7 +196,7 @@ def add_operation(self, operation: nn.Module) -> None:
         self.operations.add_module(str(len(self.operations)), operation)
 
 
-class ConfigurableBlock(BaseBlock):
+class ConfigurableBlock(BaseConvBlock):
     """
     Base class for blocks with extensive configuration options.
 

src/faith/train/blocks/residual.py

@@ -7,10 +7,10 @@
 import torch
 import torch.nn as nn
 from typing import Union, Any
-from .base import BaseBlock, WeightInitializer
+from .base import BaseConvBlock, WeightInitializer
 
 
-class ResidualBlock(BaseBlock):
+class ResidualBlock(BaseConvBlock):
     """Residual convolutional block with batch normalization and ReLU.
 
     This block implements a standard residual connection with two convolutional
@@ -27,9 +27,6 @@ class ResidualBlock(BaseBlock):
         Size of the convolving kernel.
     stride : int or tuple of int, default=1
         Stride of the convolution.
-    padding : int, tuple of int, or str, default='auto'
-        Padding added to all four sides of the input. If 'auto', padding is
-        calculated to maintain spatial dimensions when stride=1.
     bias : bool, default=True
         If True, adds a learnable bias to the output.
     use_batch_norm : bool, default=True
@@ -78,7 +75,6 @@ def __init__(
             out_channels: int,
             kernel_size: Union[int, tuple[int, int]] = 3,
             stride: Union[int, tuple[int, int]] = 1,
-            padding: Union[int, tuple[int, int], str] = 'auto',
             bias: bool = True,
             use_batch_norm: bool = True,
             activation: str = 'relu',
@@ -96,8 +92,6 @@ def __init__(
             Size of the convolving kernel.
         stride : int or tuple of int, default=1
             Stride of the convolution.
-        padding : int, tuple of int, or str, default='auto'
-            Padding specification.
         bias : bool, default=True
             Whether to use bias in convolutions.
         use_batch_norm : bool, default=True
@@ -110,9 +104,20 @@ def __init__(
         # Initialize base class
         super().__init__(in_channels, out_channels, kernel_size, bias)
 
+        if isinstance(stride, int) and stride < 1:
+            raise ValueError(f"Stride must be a positive integer or tuple, "
+                             f"got {stride}")
+        if isinstance(stride, tuple) and any(s < 1 for s in stride):
+            raise ValueError(f"Stride must be a positive integer or tuple, "
+                             f"got {stride}")
+        if (isinstance(stride, float) or isinstance(stride, tuple)
+                and any(isinstance(s, float) for s in stride)):
+            raise TypeError(f"Stride must be an integer or tuple, "
+                            f"got float {stride}")
+
         # Normalize stride and padding
         self.stride = self._normalize_stride(stride)
-        self.padding = self._calculate_padding(self.kernel_size, padding)
+        self.padding = self._calculate_padding(self.kernel_size, "auto")
         self.use_batch_norm = use_batch_norm
         self.activation_name = activation
         self.init_method = init_method
@@ -239,8 +244,9 @@ def forward(self, x: torch.Tensor) -> torch.Tensor:
         Returns
         -------
         torch.Tensor
-            Output tensor with shape (batch_size, out_channels, height', width')
-            where height' and width' depend on stride.
+            Output tensor with shape
+            (batch_size, out_channels, height', width') where height'
+            and 'width' depend on stride.
         """
         # Store input for residual connection
         residual = x
@@ -350,4 +356,4 @@ def get_output_shape(
 
         # Update channels
         batch_size, _, height, width = temp_shape
-        return (batch_size, self.out_channels, height, width)
+        return batch_size, self.out_channels, height, width

tests/test_train_blocks_base.py

@@ -1,10 +1,10 @@
 import torch
-from src.faith.train.blocks import BaseBlock, BlockUtils
+from src.faith.train.blocks import BaseConvBlock, BlockUtils
 
 
 # Example of how the base classes would be used
 
-class ExampleBlock(BaseBlock):
+class ExampleBlock(BaseConvBlock):
     """Example implementation of BaseBlock."""
 
     def __init__(self, in_channels: int, out_channels: int, **kwargs):