Skip weight quantizers with no stored weight in fold_weight

CHANGELOG.rst

@@ -25,6 +25,7 @@ Changelog
 
 **Bug Fixes**
 
+- Fix ``mtq.fold_weight`` crashing with ``AttributeError: 'NoneType' object has no attribute 'data'`` on Megatron-Core models with tied word embeddings: the tied ``output_layer`` (built with ``skip_weight_param_allocation``) stores ``weight = None`` and borrows the embedding weight at forward time, yet still carries a ``weight_quantizer``. Weight-quantizer pairs whose weight is not a stored tensor are now skipped and left untouched.
 - Fix EAGLE-3 training with context parallelism (``--cp_size > 1`` in ``examples/speculative_decoding``), which failed to start on ``accelerate >= 1.13`` and then raised ``got mixed torch.Tensor and DTensor``.
 
 0.46 (2026-08-17)

modelopt/torch/quantization/nn/modules/quant_module.py

@@ -157,6 +157,14 @@ def fold_weight(self, keep_attrs: bool = False):
         transform is baked into the stored weight and then disabled, so subsequent forwards use
         the stored weight directly. Calibration buffers (``_pre_quant_scale``, ``_amax``) are
         dropped unless ``keep_attrs``.
+
+        Quantizers whose weight attribute is not a tensor are skipped and left untouched:
+        modules such as Megatron tied-embedding output layers (built with
+        ``skip_weight_param_allocation``) store ``weight = None`` and receive the shared
+        weight as a forward-time argument, so there is nothing stored to fold. Such quantizers
+        stay enabled after folding, so callers that assert all weight quantizers are disabled
+        once folding completes (e.g. ``_check_all_weight_quantizers_disabled`` in the vLLM
+        fakequant export plugin) must account for them.
         """
         # Handle all attributes that end with _weight_quantizer
         for name in dir(self):
@@ -173,6 +181,10 @@ def fold_weight(self, keep_attrs: bool = False):
                     f"{name} doesn't have a corresponding {weight_name} in {self.__class__.__name__}"
                 )
                 weight = getattr(self, weight_name)
+                if not isinstance(weight, torch.Tensor):
+                    # e.g. Megatron tied-embedding output_layer: weight is None and
+                    # borrowed at forward time, so there is nothing stored to fold.
+                    continue
                 self._fold_weight_quantizer(attr, (weight,), keep_attrs)
 
 

tests/unit/torch/quantization/test_tensor_quant_cpu.py

@@ -332,6 +332,25 @@ def test_fold_weight_keep_attrs_keeps_amax(monkeypatch):
         unregister_quant_backend(backend_name)
 
 
+def test_fold_weight_skips_none_weight():
+    """A weight quantizer with no stored weight is skipped instead of crashing.
+
+    Megatron-Core tied-embedding output layers are built with
+    ``skip_weight_param_allocation``: the module stores ``weight = None`` and borrows the
+    embedding weight at forward time, while still carrying a ``weight_quantizer``.
+    ``fold_weight`` must skip the pair, leaving the quantizer intact for forward-time use.
+    """
+    qlinear = QuantModuleRegistry.convert(torch.nn.Linear(4, 3))
+    qlinear.weight_quantizer.amax = torch.tensor(1.0)
+    expected_amax = qlinear.weight_quantizer.amax.detach().clone()
+    qlinear.register_parameter("weight", None)
+
+    qlinear.fold_weight()  # must not raise
+
+    assert qlinear.weight_quantizer.is_enabled
+    assert torch.equal(qlinear.weight_quantizer.amax, expected_amax)
+
+
 WINT4INT8_CFG = {
     "quant_cfg": [
         {"quantizer_name": "*", "enable": False},