two-level bootstrap (windows + runs); element-wise cast check script and report; corpora hashes

logs/aggregate.py

@@ -1,19 +1,23 @@
-"""Aggregate every measured run per build: run-level means, their spread, and
-paired comparisons that average the per-window means over runs first.
+"""Per-build means over runs, run-to-run spread, and paired comparisons with TWO
+bootstrap variants:
 
-    python3 agg.py            # reads /logs/kld-<run>-<corpus>.json written by the new nvfp4_kld
+  windows-only : per-window means averaged over runs first, then windows
+                 resampled jointly for both builds. Run results are fixed, so the
+                 interval covers the spread across the corpus only.
+  windows+runs : each bootstrap draw resamples the windows jointly AND, for each
+                 build independently, its runs with replacement. The reference is
+                 fixed. With three runs per build this is a coarse but honest
+                 account of the run-to-run uncertainty the first variant ignores.
 
-Builds are named by prefix: ref-repeat, ref-r3, ref-b1 are runs of the original
-(ref-b1 kept apart as the batch=1 diagnostic), flat / flat-r2 / flat-r3 the cast,
-nvidia / nvidia-r2 / nvidia-r3 the calibrated build. All runs on one corpus must
-share the coarsening set (nvfp4_kld --also every other run), which the toolbox
-does when every dump is present before nvfp4_kld runs.
+Reads /logs/kld-<run>-<corpus>.json written by nvfp4_kld.py (common coarsening set
+required for pairing; the script checks it).
 """
-import glob, json, os, re
+import glob, json, os
 import numpy as np
-rng = np.random.default_rng(0); B = 20000
+rng = np.random.default_rng(0); B = 50000
 corpora = ["neutral", "code", "agentic"]
-groups = {"original": ["ref-repeat", "ref-r3"], "original-batch1": ["ref-b1"], "flat": ["flat", "flat-r2", "flat-r3"], "nvidia": ["nvidia", "nvidia-r2", "nvidia-r3"]}
+groups = {"original": ["ref-repeat", "ref-r3"], "original-batch1": ["ref-b1"],
+          "flat": ["flat", "flat-r2", "flat-r3"], "nvidia": ["nvidia", "nvidia-r2", "nvidia-r3"]}
 for c in corpora:
     runs = {}
     for p in glob.glob(f"/logs/kld-*-{c}.json"):
@@ -21,22 +25,32 @@ for c in corpora:
         if "window_kld" in r: runs[name] = r
     if not runs: continue
     sets = {tuple(r["coarsening_runs"]) for r in runs.values()}
-    print(f"\n=== {c}: {len(runs)} runs, coarsening sets: {len(sets)} (must be 1 for pairing)   reference ppl {next(iter(runs.values()))['ref_ppl']:.4f}")
-    print(f"{'build':16s} {'runs':>4s} {'KL_lb mean of runs':>19s} {'run SD':>8s} {'per-run means':>34s} {'top-1 %':>9s} {'run SD':>7s} {'ppl mean':>9s}")
-    W = None; gw = {}
+    ref_ppl = next(iter(runs.values()))["ref_ppl"]
+    print(f"\n=== {c}: {len(runs)} runs, coarsening sets: {len(sets)} (must be 1)   reference ppl {ref_ppl:.4f}")
+    print(f"{'build':16s} {'runs':>4s} {'KL_lb mean of runs':>19s} {'run SD':>8s} {'per-run means':>30s} {'top-1 %':>8s} {'run SD':>7s} {'ppl mean':>9s} {'d ppl':>7s}")
+    M = {}  # build -> (runs x W) per-window kl, (runs x W) per-window top1
     for g, names in groups.items():
         rs = [runs[n] for n in names if n in runs]
         if not rs: continue
+        M[g] = (np.array([r["window_kld"] for r in rs]), np.array([r["window_top1"] for r in rs]))
         k = np.array([r["mean_kld_lb"] for r in rs]); t = np.array([r["top1_agree_pct"] for r in rs]); pp = np.array([r["quant_ppl"] for r in rs])
-        gw[g] = (np.mean([r["window_kld"] for r in rs], axis=0), np.mean([r["window_top1"] for r in rs], axis=0))
         sd = lambda x: (f"{x.std(ddof=1):.5f}" if len(x) > 1 else "n/a")
-        print(f"{g:16s} {len(rs):4d} {k.mean():19.5f} {sd(k):>8s} {'  '.join(f'{v:.5f}' for v in k):>34s} {t.mean():9.2f} {sd(t):>7s} {pp.mean():9.4f}")
-    def pair(a, b):
-        da = gw[a][0] - gw[b][0]; dt = (gw[a][1] - gw[b][1]) * 100; Wn = len(da); idx = rng.integers(0, Wn, (B, Wn))
-        sa, st = da[idx].mean(1), dt[idx].mean(1)
-        return da.mean(), np.percentile(sa, 2.5), np.percentile(sa, 97.5), (sa > 0).mean(), dt.mean(), np.percentile(st, 2.5), np.percentile(st, 97.5)
-    print("paired over windows, per-window means averaged over runs first, A - B [95% CI]:")
+        print(f"{g:16s} {len(rs):4d} {k.mean():19.5f} {sd(k):>8s} {'  '.join(f'{v:.5f}' for v in k):>30s} {t.mean():8.2f} {sd(t):>7s} {pp.mean():9.4f} {100*(pp.mean()/ref_ppl-1):+6.2f}%")
+    def boot(a, b, which, two_level):
+        A, Bm = M[a][which], M[b][which]; W = A.shape[1]; scale = 100.0 if which == 1 else 1.0
+        widx = rng.integers(0, W, (B, W))
+        if two_level:
+            ra = rng.integers(0, A.shape[0], (B, A.shape[0])); rb = rng.integers(0, Bm.shape[0], (B, Bm.shape[0]))
+            am = np.stack([A[ra[i]].mean(0)[widx[i]].mean() for i in range(B)]); bm = np.stack([Bm[rb[i]].mean(0)[widx[i]].mean() for i in range(B)])
+            s = (am - bm) * scale
+        else:
+            d = (A.mean(0) - Bm.mean(0)) * scale; s = d[widx].mean(1)
+        pt = (A.mean(0) - Bm.mean(0)).mean() * scale
+        return pt, np.percentile(s, 2.5), np.percentile(s, 97.5), (s > 0).mean()
+    print("paired A - B: point estimate, then [95% CI windows-only]  [95% CI windows+runs]:")
     for a, b in (("nvidia", "flat"), ("flat", "original"), ("nvidia", "original"), ("original-batch1", "original")):
-        if a in gw and b in gw:
-            m, lo, hi, pp_, t, tlo, thi = pair(a, b)
-            print(f"  {a:>15s} - {b:9s} KL_lb {m:+.5f} [{lo:+.5f}, {hi:+.5f}] P(A>B)={pp_:.3f}   top-1 {t:+.2f} pt [{tlo:+.2f}, {thi:+.2f}]")
+        if a not in M or b not in M: continue
+        for which, label in ((0, "KL_lb"), (1, "top-1 pt")):
+            p1, lo1, hi1, pp1 = boot(a, b, which, False); p2, lo2, hi2, pp2 = boot(a, b, which, True)
+            f = "%+.5f" if which == 0 else "%+.2f"
+            print(f"  {a:>15s} - {b:9s} {label:8s} " + f % p1 + "   [" + f % lo1 + ", " + f % hi1 + "]   [" + f % lo2 + ", " + f % hi2 + "]   P(A>B) %.3f / %.3f" % (pp1, pp2))

logs/aggregate.txt

@@ -1,36 +1,48 @@
 
-=== neutral: 9 runs, coarsening sets: 1 (must be 1 for pairing)   reference ppl 2.9685
-build            runs  KL_lb mean of runs   run SD                      per-run means   top-1 %  run SD  ppl mean
-original            2             0.01596  0.00013                   0.01586  0.01605     96.13 0.07769    2.9689
-original-batch1     1             0.01676      n/a                            0.01676     95.90     n/a    2.9645
-flat                3             0.03459  0.00040          0.03433  0.03438  0.03505     94.29 0.10161    2.9901
-nvidia              3             0.03548  0.00020          0.03530  0.03570  0.03543     94.10 0.04523    2.9938
-paired over windows, per-window means averaged over runs first, A - B [95% CI]:
-           nvidia - flat      KL_lb +0.00089 [+0.00037, +0.00143] P(A>B)=0.999   top-1 -0.19 pt [-0.34, -0.05]
-             flat - original  KL_lb +0.01863 [+0.01599, +0.02157] P(A>B)=1.000   top-1 -1.84 pt [-2.05, -1.64]
-           nvidia - original  KL_lb +0.01952 [+0.01680, +0.02238] P(A>B)=1.000   top-1 -2.03 pt [-2.26, -1.80]
-  original-batch1 - original  KL_lb +0.00080 [+0.00044, +0.00115] P(A>B)=1.000   top-1 -0.23 pt [-0.35, -0.10]
+=== neutral: 9 runs, coarsening sets: 1 (must be 1)   reference ppl 2.9685
+build            runs  KL_lb mean of runs   run SD                  per-run means  top-1 %  run SD  ppl mean   d ppl
+original            2             0.01596  0.00013               0.01586  0.01605    96.13 0.07769    2.9689  +0.01%
+original-batch1     1             0.01676      n/a                        0.01676    95.90     n/a    2.9645  -0.14%
+flat                3             0.03459  0.00040      0.03433  0.03438  0.03505    94.29 0.10161    2.9901  +0.72%
+nvidia              3             0.03548  0.00020      0.03530  0.03570  0.03543    94.10 0.04523    2.9938  +0.85%
+paired A - B: point estimate, then [95% CI windows-only]  [95% CI windows+runs]:
+           nvidia - flat      KL_lb    +0.00089   [+0.00037, +0.00143]   [+0.00008, +0.00186]   P(A>B) 1.000 / 0.985
+           nvidia - flat      top-1 pt -0.19   [-0.34, -0.05]   [-0.41, +0.03]   P(A>B) 0.004 / 0.043
+             flat - original  KL_lb    +0.01863   [+0.01597, +0.02159]   [+0.01592, +0.02167]   P(A>B) 1.000 / 1.000
+             flat - original  top-1 pt -1.84   [-2.06, -1.65]   [-2.11, -1.59]   P(A>B) 0.000 / 0.000
+           nvidia - original  KL_lb    +0.01952   [+0.01681, +0.02247]   [+0.01677, +0.02247]   P(A>B) 1.000 / 1.000
+           nvidia - original  top-1 pt -2.03   [-2.26, -1.81]   [-2.29, -1.77]   P(A>B) 0.000 / 0.000
+  original-batch1 - original  KL_lb    +0.00080   [+0.00045, +0.00115]   [+0.00040, +0.00121]   P(A>B) 1.000 / 1.000
+  original-batch1 - original  top-1 pt -0.23   [-0.35, -0.10]   [-0.37, -0.05]   P(A>B) 0.000 / 0.007
 
-=== code: 9 runs, coarsening sets: 1 (must be 1 for pairing)   reference ppl 1.8919
-build            runs  KL_lb mean of runs   run SD                      per-run means   top-1 %  run SD  ppl mean
-original            2             0.01022  0.00017                   0.01010  0.01034     97.69 0.00144    1.8907
-original-batch1     1             0.01108      n/a                            0.01108     97.55     n/a    1.8922
-flat                3             0.01942  0.00060          0.01907  0.02011  0.01909     96.77 0.06292    1.8995
-nvidia              3             0.02008  0.00031          0.01980  0.02042  0.02001     96.65 0.09236    1.8991
-paired over windows, per-window means averaged over runs first, A - B [95% CI]:
-           nvidia - flat      KL_lb +0.00065 [+0.00021, +0.00113] P(A>B)=0.999   top-1 -0.12 pt [-0.22, -0.03]
-             flat - original  KL_lb +0.00920 [+0.00621, +0.01232] P(A>B)=1.000   top-1 -0.92 pt [-1.28, -0.59]
-           nvidia - original  KL_lb +0.00986 [+0.00676, +0.01320] P(A>B)=1.000   top-1 -1.03 pt [-1.46, -0.65]
-  original-batch1 - original  KL_lb +0.00087 [+0.00032, +0.00144] P(A>B)=0.999   top-1 -0.14 pt [-0.26, -0.02]
+=== code: 9 runs, coarsening sets: 1 (must be 1)   reference ppl 1.8919
+build            runs  KL_lb mean of runs   run SD                  per-run means  top-1 %  run SD  ppl mean   d ppl
+original            2             0.01022  0.00017               0.01010  0.01034    97.69 0.00144    1.8907  -0.06%
+original-batch1     1             0.01108      n/a                        0.01108    97.55     n/a    1.8922  +0.02%
+flat                3             0.01942  0.00060      0.01907  0.02011  0.01909    96.77 0.06292    1.8995  +0.40%
+nvidia              3             0.02008  0.00031      0.01980  0.02042  0.02001    96.65 0.09236    1.8991  +0.38%
+paired A - B: point estimate, then [95% CI windows-only]  [95% CI windows+runs]:
+           nvidia - flat      KL_lb    +0.00065   [+0.00020, +0.00112]   [-0.00019, +0.00152]   P(A>B) 0.998 / 0.938
+           nvidia - flat      top-1 pt -0.12   [-0.22, -0.03]   [-0.29, +0.04]   P(A>B) 0.004 / 0.070
+             flat - original  KL_lb    +0.00920   [+0.00617, +0.01235]   [+0.00614, +0.01245]   P(A>B) 1.000 / 1.000
+             flat - original  top-1 pt -0.92   [-1.28, -0.59]   [-1.29, -0.58]   P(A>B) 0.000 / 0.000
+           nvidia - original  KL_lb    +0.00986   [+0.00671, +0.01316]   [+0.00668, +0.01323]   P(A>B) 1.000 / 1.000
+           nvidia - original  top-1 pt -1.03   [-1.46, -0.65]   [-1.48, -0.64]   P(A>B) 0.000 / 0.000
+  original-batch1 - original  KL_lb    +0.00087   [+0.00032, +0.00143]   [+0.00025, +0.00150]   P(A>B) 0.999 / 0.998
+  original-batch1 - original  top-1 pt -0.14   [-0.27, -0.02]   [-0.27, -0.01]   P(A>B) 0.012 / 0.017
 
-=== agentic: 9 runs, coarsening sets: 1 (must be 1 for pairing)   reference ppl 1.3861
-build            runs  KL_lb mean of runs   run SD                      per-run means   top-1 %  run SD  ppl mean
-original            2             0.00537  0.00020                   0.00551  0.00522     98.67 0.05035    1.3856
-original-batch1     1             0.00585      n/a                            0.00585     98.65     n/a    1.3863
-flat                3             0.00856  0.00019          0.00852  0.00839  0.00876     98.37 0.03692    1.3875
-nvidia              3             0.00888  0.00011          0.00892  0.00876  0.00897     98.34 0.05345    1.3873
-paired over windows, per-window means averaged over runs first, A - B [95% CI]:
-           nvidia - flat      KL_lb +0.00033 [-0.00000, +0.00066] P(A>B)=0.974   top-1 -0.02 pt [-0.10, +0.05]
-             flat - original  KL_lb +0.00319 [+0.00261, +0.00386] P(A>B)=1.000   top-1 -0.30 pt [-0.37, -0.23]
-           nvidia - original  KL_lb +0.00352 [+0.00292, +0.00420] P(A>B)=1.000   top-1 -0.33 pt [-0.42, -0.23]
-  original-batch1 - original  KL_lb +0.00048 [-0.00001, +0.00104] P(A>B)=0.973   top-1 -0.02 pt [-0.13, +0.09]
+=== agentic: 9 runs, coarsening sets: 1 (must be 1)   reference ppl 1.3861
+build            runs  KL_lb mean of runs   run SD                  per-run means  top-1 %  run SD  ppl mean   d ppl
+original            2             0.00537  0.00020               0.00551  0.00522    98.67 0.05035    1.3856  -0.04%
+original-batch1     1             0.00585      n/a                        0.00585    98.65     n/a    1.3863  +0.01%
+flat                3             0.00856  0.00019      0.00852  0.00839  0.00876    98.37 0.03692    1.3875  +0.10%
+nvidia              3             0.00888  0.00011      0.00892  0.00876  0.00897    98.34 0.05345    1.3873  +0.09%
+paired A - B: point estimate, then [95% CI windows-only]  [95% CI windows+runs]:
+           nvidia - flat      KL_lb    +0.00033   [-0.00000, +0.00066]   [-0.00014, +0.00076]   P(A>B) 0.974 / 0.924
+           nvidia - flat      top-1 pt -0.02   [-0.10, +0.05]   [-0.13, +0.09]   P(A>B) 0.251 / 0.306
+             flat - original  KL_lb    +0.00319   [+0.00262, +0.00387]   [+0.00253, +0.00396]   P(A>B) 1.000 / 1.000
+             flat - original  top-1 pt -0.30   [-0.37, -0.23]   [-0.40, -0.20]   P(A>B) 0.000 / 0.000
+           nvidia - original  KL_lb    +0.00352   [+0.00292, +0.00419]   [+0.00285, +0.00428]   P(A>B) 1.000 / 1.000
+           nvidia - original  top-1 pt -0.33   [-0.42, -0.23]   [-0.44, -0.19]   P(A>B) 0.000 / 0.000
+  original-batch1 - original  KL_lb    +0.00048   [+0.00000, +0.00105]   [-0.00009, +0.00109]   P(A>B) 0.975 / 0.952
+  original-batch1 - original  top-1 pt -0.02   [-0.13, +0.09]   [-0.14, +0.11]   P(A>B) 0.361 / 0.367

logs/cast-check.py

@@ -0,0 +1,40 @@
+"""Element-wise check of the MXFP4 -> NVFP4 cast on a sample of experts.
+
+    python3 cast-check.py SRC_DIR EXPORT_DIR
+
+Dequantizes each sampled expert projection from the source (E2M1 nibbles x 2^E8M0 per 32)
+and from the export (E2M1 nibbles x E4M3 per 16 x fp32 per tensor) and compares the float32
+values element by element. Also reports whether the packed bytes are identical, and, where
+they are not, whether every differing nibble is a +0/-0 pair (E2M1 has two zeros).
+"""
+import json, random, sys, torch
+from safetensors import safe_open
+src, exp = sys.argv[1], sys.argv[2]
+FP4 = torch.tensor([0,.5,1,1.5,2,3,4,6,0,-.5,-1,-1.5,-2,-3,-4,-6], dtype=torch.float32)
+si = json.load(open(src+"/model.safetensors.index.json"))["weight_map"]; ei = json.load(open(exp+"/model.safetensors.index.json"))["weight_map"]
+def get(root, idx, name):
+    with safe_open(root+"/"+idx[name], "pt", "cpu") as f: return f.get_tensor(name)
+def nib(x):
+    u = x.contiguous().view(torch.uint8); lo, hi = u & 0xF, (u >> 4) & 0xF
+    return torch.stack([FP4[lo.long()], FP4[hi.long()]], -1).flatten(-2)
+random.seed(0)
+picks = [(0,0),(0,383),(14,7),(20,200),(39,5),(39,383)] + [(random.randrange(40), random.randrange(384)) for _ in range(6)]
+n = exact = same = zero_only = 0; params = 0; worst = 0.0
+for l, e in picks:
+    for w in ("w1","w2","w3"):
+        b = f"layers.{l}.ffn.experts.{e}.{w}"
+        sw, ss = get(src, si, b+".weight"), get(src, si, b+".scale")
+        ew, es, es2 = get(exp, ei, b+".weight"), get(exp, ei, b+".weight_scale"), get(exp, ei, b+".weight_scale_2")
+        k = (ss.view(torch.uint8).to(torch.int32) - 127).float()
+        d_src = nib(sw) * torch.pow(2.0, k).repeat_interleave(32, 1)
+        d_exp = nib(ew) * (es.float() * es2.float()).repeat_interleave(16, 1)
+        eq = torch.equal(d_src, d_exp); md = (d_src - d_exp).abs().max().item(); worst = max(worst, md)
+        su, eu = sw.contiguous().view(torch.uint8), ew.contiguous().view(torch.uint8)
+        sb = torch.equal(su, eu)
+        if not sb:
+            lo_ok = (((su & 0xF) == (eu & 0xF)) | (((su & 0xF) + (eu & 0xF)) == 8)).all()
+            hi_ok = (((su >> 4) == (eu >> 4)) | (((su >> 4) + (eu >> 4)) == 8)).all()
+            zero_only += bool(lo_ok and hi_ok)
+        n += 1; exact += eq; same += sb; params += d_src.numel()
+        print(f"{b:32s} dequant identical: {eq}  max|diff| {md:.1e}  bytes identical: {sb}" + ("" if sb else f"  differing nibbles all +0/-0: {bool(lo_ok and hi_ok)}"))
+print(f"\n{n} tensors, {params/1e9:.2f} G parameters: dequantized values identical {exact}/{n} (worst |diff| {worst:.1e}); packed bytes identical {same}/{n}; byte differences that are only +0/-0 pairs {zero_only}/{n-same}")

logs/cast-check.txt

@@ -0,0 +1,38 @@
+layers.0.ffn.experts.0.w1        dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.0.ffn.experts.0.w2        dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.0.ffn.experts.0.w3        dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.0.ffn.experts.383.w1      dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.0.ffn.experts.383.w2      dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.0.ffn.experts.383.w3      dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.14.ffn.experts.7.w1       dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.14.ffn.experts.7.w2       dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.14.ffn.experts.7.w3       dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.20.ffn.experts.200.w1     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.20.ffn.experts.200.w2     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.20.ffn.experts.200.w3     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.39.ffn.experts.5.w1       dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.39.ffn.experts.5.w2       dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.39.ffn.experts.5.w3       dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.39.ffn.experts.383.w1     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.39.ffn.experts.383.w2     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.39.ffn.experts.383.w3     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.24.ffn.experts.215.w1     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.24.ffn.experts.215.w2     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.24.ffn.experts.215.w3     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.2.ffn.experts.132.w1      dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.2.ffn.experts.132.w2      dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.2.ffn.experts.132.w3      dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.32.ffn.experts.248.w1     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.32.ffn.experts.248.w2     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.32.ffn.experts.248.w3     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.25.ffn.experts.155.w1     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.25.ffn.experts.155.w2     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.25.ffn.experts.155.w3     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.30.ffn.experts.183.w1     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.30.ffn.experts.183.w2     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.30.ffn.experts.183.w3     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.37.ffn.experts.111.w1     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.37.ffn.experts.111.w2     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+layers.37.ffn.experts.111.w3     dequant identical: True  max|diff| 0.0e+00  bytes identical: False  differing nibbles all +0/-0: True
+
+36 tensors, 0.42 G parameters: dequantized values identical 36/36 (worst |diff| 0.0e+00); packed bytes identical 0/36; byte differences that are only +0/-0 pairs 36/36

logs/corpora-sha256.txt

@@ -0,0 +1,7 @@
+# measurement corpora as used on the box, sha256 and size
+1b91967fa31d3c1fcf89c4212654662bbd983c7cea7f8be75405072c92da978e  1560115  neutral.txt
+5390c306c216c9af63eb9e7761dd02793d43ecc8719a12a365a34a9314395a87  1451207  code.txt
+b6fe570299d8e0efcccee5eab7b3b42f0f6fcb680aab71d0e4134883696820f9  1385645  agentic.txt
+
+# origin: AtomicChat/calib-corpora eval/neutral/eval_neutral.txt, eval/code/eval_code_full.txt, eval/agentic/eval_agentic.txt, downloaded 2026-09-10 16:29 UTC
+# note: eval_agentic.txt is agentic dialogue rendered in Muse Glimmer markup (<|start|>, atem:function_calls), not DeepSeek's DSML; it is scored as plain text by V4.1's tokenizer