# Cross-Backbone Adapter Swap — train on X, evaluate on Y

Evaluations: **240** rows (2 model sizes x 4 tasks x 3 eval backbones x (3 train backbones x 3 seeds + no-adapter))

`penalty = matched accuracy − swapped accuracy`, computed **within a fixed evaluation backbone**, so it isolates adapter transfer from backbone quality.

## Reference floor — backbone with NO adapter

| model_size   |   bf16 |   int8 |    nf4 |
|:-------------|-------:|-------:|-------:|
| 1B           | 0.5196 | 0.5045 | 0.4962 |
| 3B           | 0.5049 | 0.5050 | 0.5047 |

## Llama-3.2-1B

Accuracy (rows = TRAIN backbone, cols = EVAL backbone):

| train_bitwidth   |   bf16 |   int8 |    nf4 |
|:-----------------|-------:|-------:|-------:|
| bf16             | 0.8251 | 0.8140 | 0.7928 |
| int8             | 0.8216 | 0.8203 | 0.7894 |
| nf4              | 0.8118 | 0.8099 | 0.8272 |

Transfer penalty in percentage points (positive = swapping hurts):

| train_bitwidth   |   bf16 |   int8 |   nf4 |
|:-----------------|-------:|-------:|------:|
| bf16             |  +0.00 |  +0.63 | +3.44 |
| int8             |  +0.35 |  +0.00 | +3.77 |
| nf4              |  +1.33 |  +1.05 | +0.00 |

- mean off-diagonal penalty: **+1.76 pp** (worst +3.77 pp, best +0.35 pp)

## Llama-3.2-3B

Accuracy (rows = TRAIN backbone, cols = EVAL backbone):

| train_bitwidth   |   bf16 |   int8 |    nf4 |
|:-----------------|-------:|-------:|-------:|
| bf16             | 0.8940 | 0.8931 | 0.8942 |
| int8             | 0.8977 | 0.8945 | 0.8935 |
| nf4              | 0.8928 | 0.8906 | 0.8960 |

Transfer penalty in percentage points (positive = swapping hurts):

| train_bitwidth   |   bf16 |   int8 |   nf4 |
|:-----------------|-------:|-------:|------:|
| bf16             |  +0.00 |  +0.14 | +0.18 |
| int8             |  -0.37 |  +0.00 | +0.24 |
| nf4              |  +0.12 |  +0.39 | +0.00 |

- mean off-diagonal penalty: **+0.12 pp** (worst +0.39 pp, best -0.37 pp)

## Per-task penalty

|                |   ('bf16', 'int8') |   ('bf16', 'nf4') |   ('int8', 'bf16') |   ('int8', 'nf4') |   ('nf4', 'bf16') |   ('nf4', 'int8') |
|:---------------|-------------------:|------------------:|-------------------:|------------------:|------------------:|------------------:|
| ('1B', 'mnli') |              +0.17 |             +1.55 |              -0.07 |             +1.45 |             +0.85 |             +0.60 |
| ('1B', 'qqp')  |              +0.50 |             +0.37 |              -0.27 |             +0.45 |             -0.12 |             +0.22 |
| ('1B', 'rte')  |              +1.93 |            +11.79 |              +1.68 |            +13.12 |             +4.57 |             +3.25 |
| ('1B', 'sst2') |              -0.08 |             +0.04 |              +0.04 |             +0.08 |             +0.00 |             +0.11 |
| ('3B', 'mnli') |              -0.03 |             +0.03 |              -0.17 |             +0.00 |             +0.53 |             +0.43 |
| ('3B', 'qqp')  |              +0.67 |             +0.62 |              -0.32 |             -0.07 |             +0.33 |             +0.75 |
| ('3B', 'rte')  |              -0.36 |             -0.24 |              -0.72 |             +0.72 |             -0.72 |             -0.12 |
| ('3B', 'sst2') |              +0.31 |             +0.31 |              -0.27 |             +0.31 |             +0.34 |             +0.50 |

## Interpretation

**Degenerate cells excluded from the headline** (mean accuracy within 10 pp of the majority-class floor — the adapter barely learned, so its 'transfer penalty' is mostly label noise):

| model_size   | task   |    acc |   floor |   margin |
|:-------------|:-------|-------:|--------:|---------:|
| 1B           | rte    | 0.5681 |  0.5271 |   0.0410 |

Mean off-diagonal transfer penalty (pp):

| model_size   |   all_tasks_pp |   excluding_degenerate_pp |
|:-------------|---------------:|--------------------------:|
| 1B           |          +1.76 |                     +0.33 |
| 3B           |          +0.12 |                     +0.12 |

- Excluding degenerate cells, the mean transfer penalty is **+0.21 pp**.

- **Adapters transfer between backbones essentially for free.** Combined with the geometry result (cross-bit cosine 0.45–0.66, sign agreement ~0.65), this says the bit-width-induced rotation is **functionally redundant**: adapters trained against different backbones take measurably different routes to the same behaviour. Different solution, same function — evidence that the rank-16 solution space is highly degenerate.

- Residual structure by **deployment** backbone (pp): 1B/eval-on-bf16 +0.07; 1B/eval-on-int8 +0.25; 1B/eval-on-nf4 +0.66; 3B/eval-on-bf16 -0.12; 3B/eval-on-int8 +0.27; 3B/eval-on-nf4 +0.21

- The small residual is concentrated on *deploying onto* NF4, not on *training on* it — consistent with NF4 being the most perturbed backbone, but the magnitude is under 1 pp.

> ⚠️ Scope: this swaps ONE adapter at a time. It shows an individual adapter is robust to a backbone change; it does not by itself establish that MERGED adapters are, since merging compounds direction and sign disagreement across several adapters at once.