feat: add HardSwish activation function

src/brevitas/nn/__init__.py

@@ -4,6 +4,7 @@
 from .hadamard_classifier import HadamardClassifier
 from .quant_accumulator import ClampQuantAccumulator
 from .quant_accumulator import TruncQuantAccumulator
+from .quant_activation import QuantHardSwish
 from .quant_activation import QuantHardTanh
 from .quant_activation import QuantIdentity
 from .quant_activation import QuantReLU

src/brevitas/nn/quant_activation.py

@@ -118,3 +118,34 @@ def __init__(
             act_quant=act_quant,
             return_quant_tensor=return_quant_tensor,
             **kwargs)
+
+
+class QuantHardSwish(QuantNLAL):
+    """
+    Quantized HardSwish activation.
+
+    This is a baseline implementation using unsigned quantization (Uint8ActPerTensorFloat).
+    HardSwish output range is approximately [-0.33, ∞), and unsigned quantization clamps
+    the small negative values to zero, which is acceptable for most use cases.
+
+    For hardware-specific optimizations, consider:
+    - Asymmetric quantization with learned zero-point for better range utilization
+    - Hardware-specific quantization schemes that match your deployment target
+
+    Users should validate this implementation works for their specific use case.
+    """
+
+    def __init__(
+            self,
+            act_quant: Optional[ActQuantType] = Uint8ActPerTensorFloat,
+            input_quant: Optional[ActQuantType] = None,
+            return_quant_tensor: bool = False,
+            **kwargs):
+        QuantNLAL.__init__(
+            self,
+            act_impl=nn.Hardswish,
+            passthrough_act=False,
+            input_quant=input_quant,
+            act_quant=act_quant,
+            return_quant_tensor=return_quant_tensor,
+            **kwargs)

tests/brevitas/nn/test_act.py

@@ -4,6 +4,7 @@
 import pytest
 import torch
 
+from brevitas.nn import QuantHardSwish
 from brevitas.nn import QuantHardTanh
 from brevitas.nn import QuantIdentity
 from brevitas.nn import QuantReLU
@@ -24,6 +25,51 @@ def test_module_init_const_scaling(self):
         mod = QuantReLU(max_val=6, scaling_impl_type='CONST')
 
 
+class TestQuantHardSwish:
+
+    def test_module_init_default(self):
+        mod = QuantHardSwish()
+
+    def test_module_init_with_bit_width(self):
+        # Test with custom bit width
+        mod = QuantHardSwish(bit_width=4)
+
+    def test_forward_pass(self):
+        mod = QuantHardSwish()
+        inp = torch.randn(1, 20, 10, 10)
+        out = mod(inp)
+        assert out.shape == inp.shape
+
+    def test_output_behavior(self):
+        mod = QuantHardSwish()
+        mod.eval()
+        # For large positive inputs, hardswish output should be close to input (positive)
+        inp_positive = torch.tensor([5.0, 10.0, 100.0])
+        out_positive = mod(inp_positive)
+        assert (out_positive >= 0).all().item()
+
+        # For small negative inputs, unquantized hardswish can produce small negative values
+        # HardSwish(x) ≈ -0.33 at minimum (around x=-3)
+        # With unsigned quantization (default), these small negative values are clamped to zero
+        inp_negative = torch.tensor([-2.0, -1.0, -0.5])
+        out_negative = mod(inp_negative)
+        assert (out_negative >= 0).all().item()
+
+    def test_training_eval_modes(self):
+        mod = QuantHardSwish()
+        inp = torch.randn(2, 6, 16, 16)
+
+        # Training mode
+        mod.train()
+        out_train = mod(inp)
+        assert out_train.shape == inp.shape
+
+        # Eval mode
+        mod.eval()
+        out_eval = mod(inp)
+        assert out_eval.shape == inp.shape
+
+
 class TestQuantDelay:
 
     @pytest.mark.parametrize("bw_quant_type", [(4, "INT"), (1, "BINARY"), (2, "TERNARY")])