fix(qlinear): size GPTQ buffers by pack_factor and skip Laguna g_proj quantization (#84) (#2983)

* fix(qlinear): use pack_factor for qweight/qzeros buffer sizing and mark Laguna g_proj as non-quantizable

* test(qlinear): add buffer shape test for out_features=48/72

Author: Qubitium

gptqmodel/models/definitions/laguna.py

@@ -29,7 +29,7 @@ class LagunaQModel(BaseQModel):
                 "q_proj:0",
                 "k_proj:0",
                 "v_proj:0",
-                "g_proj:0",
+                "g_proj:!",
                 "o_proj:1",
             ),
             "post_attention_layernorm": ("post_attention_layernorm:!",),

gptqmodel/nn_modules/qlinear/__init__.py

@@ -750,14 +750,14 @@ def _register_gptq_buffers(
 
         self.register_buffer(
             "qweight",
-            t.zeros((in_features // self.pack_dtype_bits * self.bits, out_features), dtype=self.pack_dtype),
+            t.zeros((math.ceil(in_features / self.pack_factor), out_features), dtype=self.pack_dtype),
         )
         self.register_buffer(
             "qzeros",
             t.zeros(
                 (
                     math.ceil(in_features / self.group_size),
-                    out_features // self.pack_dtype_bits * self.bits,
+                    math.ceil(out_features / self.pack_factor),
                 ),
                 dtype=self.pack_dtype,
             ),
@@ -1395,7 +1395,7 @@ def pack_original(self, linear: nn.Module, scales: t.Tensor, zeros: t.Tensor, g_
             int_weight = int_weight.to(t.int32).T.contiguous()
             int_weight = int_weight.numpy().astype(self.pack_np_math_dtype)
 
-            qweight = np.zeros((int_weight.shape[0] // self.pack_dtype_bits * self.bits, int_weight.shape[1]),
+            qweight = np.zeros((math.ceil(int_weight.shape[0] / self.pack_factor), int_weight.shape[1]),
                                dtype=self.pack_np_math_dtype)
             if self.bits in [2, 4, 8]:
                 for row in range(qweight.shape[0]):
@@ -1428,7 +1428,7 @@ def pack_original(self, linear: nn.Module, scales: t.Tensor, zeros: t.Tensor, g_
             self.register_buffer("qweight", t.from_numpy(qweight.astype(self.pack_np_dtype)))
 
             zeros = zeros.numpy().astype(self.pack_np_math_dtype)
-            qzeros = np.zeros((zeros.shape[0], zeros.shape[1] // self.pack_dtype_bits * self.bits), dtype=self.pack_np_math_dtype)
+            qzeros = np.zeros((zeros.shape[0], math.ceil(zeros.shape[1] / self.pack_factor)), dtype=self.pack_np_math_dtype)
             if self.bits in [2, 4, 8]:
                 for col in range(qzeros.shape[1]):
                     for j in range(self.pack_factor):

tests/kernels/test_qlinear_hierarchy.py

@@ -234,3 +234,34 @@ def test_weight_only_kernels_do_not_declare_grouped_support_metadata():
         assert not hasattr(cls, "SUPPORTS_GROUP_SIZE")
         assert not hasattr(cls, "SUPPORTS_DESC_ACT")
         assert not hasattr(cls, "SUPPORTS_SYM")
+
+
+def test_gptq_quant_linear_buffer_shapes_for_non_word_aligned_out_features():
+    """Laguna's g_proj has out_features=48/72, which is a multiple of pack_factor (8) but not pack_dtype_bits (32)."""
+    import math
+
+    for out_features in (48, 72):
+        layer = TorchLinear(
+            bits=4,
+            group_size=32,
+            sym=True,
+            desc_act=False,
+            in_features=3072,
+            out_features=out_features,
+            bias=False,
+        )
+        expected_qweight_rows = math.ceil(3072 / layer.pack_factor)
+        expected_qzeros_cols = math.ceil(out_features / layer.pack_factor)
+        assert layer.qweight.shape == (expected_qweight_rows, out_features)
+        assert layer.qzeros.shape == (math.ceil(3072 / 32), expected_qzeros_cols)
+
+        # Ensure a checkpoint with the natural packed shapes loads cleanly.
+        state = {
+            "qweight": torch.zeros((expected_qweight_rows, out_features), dtype=torch.int32),
+            "qzeros": torch.zeros((math.ceil(3072 / 32), expected_qzeros_cols), dtype=torch.int32),
+            "scales": torch.zeros((math.ceil(3072 / 32), out_features), dtype=torch.float16),
+            "g_idx": torch.tensor([i // 32 for i in range(3072)], dtype=torch.int32),
+        }
+        missing, unexpected = layer.load_state_dict(state, strict=False)
+        assert not missing
+        assert not unexpected