refactor(hf_ptq): drop the offloaded-weight pin, which the layerwise path does not need

_pin_externally_read_params existed because Kimi-K3's _apply_attn_res reads the residual
proj/norm weights from the decoder layer's forward rather than calling those modules, so
accelerate leaves them on meta. That is real for a plain full forward, but not for this
pipeline: every forward in the calibration loop runs inside persistent_materialization(layer),
which materializes the layer subtree including those modules, and the only forward outside a
window is the bootstrap capture, which early-stops before reaching them.

Measured on midi-K3 with offload genuinely engaged (--max_gpu_memory_gb 0.5
--max_cpu_memory_gb 0.1):

  pin active    exit=0 shards=9 OFFLOAD=1 PINNED=1 meta_err=0
  pin disabled  exit=0 shards=9 OFFLOAD=1 PINNED=0 meta_err=0

Exports equivalent: 2922/2922 keys, the single flagged tensor being a NaN from the fixture's
random init (identical NaN masks, all 31 finite entries equal). midi-K3 does carry the
modules in question -- 8 mlp_res_proj, 8 mlp_res_norm, 8 self_attention_res_proj, 1
output_attn_res_proj -- so the control exercises the pattern rather than skipping it.

An earlier run of this comparison was void: at --max_gpu_memory_gb 1 nothing was offloaded,
so both arms took the same resident path. The budget above is the range where accelerate
offloads part of the model; below roughly 0.05 it refuses outright.

Removing it also removes the hardcoded six-suffix Kimi-K3 module list from a shared example
helper, which applied to every offloaded run.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Signed-off-by: Fridah-nv <201670829+Fridah-nv@users.noreply.github.com>

Author: Fridah-nv

examples/hf_ptq/example_utils.py

@@ -741,61 +741,6 @@ def _force_attn_implementation(model, attn_implementation: str) -> None:
             print(f"  {line}")
 
 
-#: Modules whose weights are read from *another* module's forward, so accelerate never
-#: materializes them. Kimi-K3's ``_apply_attn_res`` does
-#: ``norm.weight.float() * proj.weight.squeeze(0).float()`` from the decoder layer's
-#: forward, reaching into these six children (``modeling_kimi_linear.py``, three call
-#: sites). Each is one row -- ``(1, hidden)`` and ``(hidden,)`` -- so pinning all of them
-#: on a 93-layer model costs single-digit MB.
-_EXTERNALLY_READ_PARAM_SUFFIXES = (
-    "self_attention_res_proj",
-    "self_attention_res_norm",
-    "mlp_res_proj",
-    "mlp_res_norm",
-    "output_attn_res_proj",
-    "output_attn_res_norm",
-)
-
-
-def _pin_externally_read_params(
-    model, suffixes: tuple[str, ...] = _EXTERNALLY_READ_PARAM_SUFFIXES
-) -> int:
-    """Make offloaded weights that are read outside their own forward permanently resident.
-
-    accelerate materializes an offloaded weight in *that module's* pre-forward hook and
-    returns it to meta in the matching post-forward. A weight read from a sibling's forward
-    is therefore on meta at the moment it is used, which surfaces as
-    ``Tensor on device meta is not on the expected device cuda:0``.
-
-    Setting the tensor is not enough on its own: ``post_forward`` walks the module's tensors
-    and pushes every one back to meta, so the hook has to go. Detaching alone is not enough
-    either -- ``AlignDevicesHook.detach_hook`` restores each tensor to
-    ``original_devices[name]`` and *skips* meta, which is precisely what a disk-offloaded
-    param has, so it would be left on meta. Retargeting ``original_devices`` at the
-    execution device first makes detach do the materialization itself, using accelerate's
-    own code path rather than a hand-rolled copy.
-
-    Safe because these modules' ``forward`` is never called -- only their raw ``.weight`` is
-    read -- so removing the hook removes nothing that was doing work.
-
-    Returns the number of modules pinned.
-    """
-    from accelerate.hooks import remove_hook_from_module
-
-    pinned = 0
-    for name, module in model.named_modules():
-        if not name.endswith(suffixes):
-            continue
-        hook = getattr(module, "_hf_hook", None)
-        if hook is None or not getattr(hook, "offload", False):
-            continue
-        device = hook.execution_device
-        hook.original_devices = dict.fromkeys(getattr(hook, "original_devices", {}), device)
-        remove_hook_from_module(module)
-        pinned += 1
-    return pinned
-
-
 def _get_config_dtype(config):
     config_dtype = (
         getattr(config, "dtype", None) or getattr(config, "torch_dtype", None) or torch.bfloat16
@@ -1066,12 +1011,6 @@ def has_pack_quantized_config(config):
     if attn_implementation is not None:
         _force_attn_implementation(model, attn_implementation)
 
-    # Offloaded weights that a sibling's forward reads would otherwise be on meta when used.
-    if _disk_offload:
-        n_pinned = _pin_externally_read_params(model)
-        if n_pinned:
-            print(f"Pinned {n_pinned} externally-read modules so offload cannot meta them.")
-
     if has_pack_quantized_config(hf_config):
         _unpack_compressed_linear_weights(model, ckpt_path)