fix: quantizer unit test fixes and tighten GPTQ thresholds (#21)

* [fix] ensure y_replaced for q/k/v projections in quantizer module test

* [test] tighten error thresholds in GPTQ quantization tests

* [update] CHANGELOG for v1.1.0+hotfix/unit_test: fix quantizer module forward test and tighten GPTQ test thresholds

* [refactor] extract duplicated forward pass into TestModel.forward() in test_module.py

* [update] CHANGELOG for v1.1.0+hotfix/unit_test: add test infrastructure entry for extracting duplicated forward pass into TestModel.forward()

---------

Co-authored-by: sikoji <seiichiro.kojio@compmind.co.jp>

Author: k-arima-3150

CHANGELOG.md

@@ -6,6 +6,18 @@
 
 - Added `.pre-commit-config.yaml` with `black`, `isort`, and local hooks (`no-japanese`, `copyright-header`, `no-email-address`); install with `uv sync --extra dev` then `pre-commit install` (see README)
 
+### Quantizer module forward test fix
+
+- Fixed `tests/onecomp/quantizer/test_module.py` to feed `y_replaced` consistently into `q_proj` / `k_proj` / `v_proj` after quantized weights are applied, aligning the replacement-path forward test with the intended residual update flow
+
+### GPTQ quantization test thresholds
+
+- Tightened GPTQ unit test tolerances in `tests/onecomp/quantizer/gptq/test_gptq.py` so regressions in dequantized-weight error are detected earlier (`error < 0.4`, `max_error < 1.71`; previously `0.6` / `2.5`)
+
+### Test infrastructure
+
+- Extracted the duplicated attention+MLP forward loop in `test_quantize_error` into `TestModel.forward()` (`tests/onecomp/quantizer/test_module.py`); both the pre-quantization and post-quantization inference paths now call `model(inp)` directly, eliminating 34 duplicate lines
+
 ## [v1.1.1] 2026-05-21
 
 ### New Feature: Quantization progress logging

tests/onecomp/quantizer/gptq/test_gptq.py

@@ -164,8 +164,8 @@ def check_quantize_error(self, error, max_error):
         Thresholds are set for FP16 dequantized weights returned by
         compute_dequantized_weight().
         """
-        assert error < 0.6
-        assert max_error < 2.5
+        assert error < 0.4
+        assert max_error < 1.71
 
     def check_forward_error(
         self,

tests/onecomp/quantizer/test_module.py

@@ -93,8 +93,23 @@ def __init__(self, hidden_size=2048):
         )
 
     def forward(self, x):
-        """Forward pass is not needed for quantization tests."""
-        pass
+        y = x
+        for layer in self.model.layers:
+            q = layer.self_attn.q_proj(y)
+            k = layer.self_attn.k_proj(y)
+            v = layer.self_attn.v_proj(y)
+            head_dim = k.shape[-1]
+            qk = torch.matmul(q, k.transpose(-2, -1)) / (head_dim**0.5)
+            attn_weights = torch.nn.functional.softmax(qk, dim=-1)
+            v = torch.matmul(attn_weights, v)
+            attn_out = layer.self_attn.o_proj(v)
+
+            gate = torch.nn.functional.silu(layer.mlp.gate_proj(y))
+            up = layer.mlp.up_proj(y)
+            mlp_out = layer.mlp.down_proj(gate * up)
+
+            y = y + attn_out + mlp_out
+        return y
 
 
 class BaseQuantizeSpec:
@@ -291,22 +306,7 @@ def test_quantize_error(self, helper):
         )
 
         with torch.no_grad():
-            y_original = inp
-            for layer in model.model.layers:
-                q = layer.self_attn.q_proj(y_original)
-                k = layer.self_attn.k_proj(y_original)
-                v = layer.self_attn.v_proj(y_original)
-                head_dim = k.shape[-1]
-                qk = torch.matmul(q, k.transpose(-2, -1)) / (head_dim**0.5)
-                attn_weights = torch.nn.functional.softmax(qk, dim=-1)
-                v = torch.matmul(attn_weights, v)
-                attn_out = layer.self_attn.o_proj(v)
-
-                gate = torch.nn.functional.silu(layer.mlp.gate_proj(y_original))
-                up = layer.mlp.up_proj(y_original)
-                mlp_out = layer.mlp.down_proj(gate * up)
-
-                y_original = y_original + attn_out + mlp_out
+            y_original = model(inp)
 
         for layer in model.model.layers:
             for _, module_dict in [
@@ -330,22 +330,7 @@ def test_quantize_error(self, helper):
         model = model.to(device)
 
         with torch.no_grad():
-            y_replaced = inp
-            for layer in model.model.layers:
-                q = layer.self_attn.q_proj(y_original)
-                k = layer.self_attn.k_proj(y_original)
-                v = layer.self_attn.v_proj(y_original)
-                head_dim = k.shape[-1]
-                qk = torch.matmul(q, k.transpose(-2, -1)) / (head_dim**0.5)
-                attn_weights = torch.nn.functional.softmax(qk, dim=-1)
-                v = torch.matmul(attn_weights, v)
-                attn_out = layer.self_attn.o_proj(v)
-
-                gate = torch.nn.functional.silu(layer.mlp.gate_proj(y_replaced))
-                up = layer.mlp.up_proj(y_replaced)
-                mlp_out = layer.mlp.down_proj(gate * up)
-
-                y_replaced = y_replaced + attn_out + mlp_out
+            y_replaced = model(inp)
 
         error = torch.norm(y_original - y_replaced) / torch.norm(y_original)
         max_error = torch.abs(y_original - y_replaced).max().item()