diffcb 0.1.7__tar.gz → 0.1.9__tar.gz

{diffcb-0.1.7 → diffcb-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffcb
-Version: 0.1.7
+Version: 0.1.9
 Summary: Differentiable Critical Bandwidth: Silverman's modality test as a differentiable PyTorch layer with IFT backward pass.
 Project-URL: Homepage, https://github.com/ryZhangHason/differentiable-critical-bandwidth
 Project-URL: Repository, https://github.com/ryZhangHason/differentiable-critical-bandwidth
@@ -295,15 +295,17 @@ Cumulative speedup vs v0.1.4 on CPU: 1.1× (100K), 1.7× (1M), **4.2× (10M)**.
 
 ```python
 DCBLayer(
-    target_modes=1,        # target number of modes (default 1)
-    use_fft=True,          # FFT path for n > 50K (default True)
-    max_n_exact=None,      # sketch above this n (None = always exact)
-    G_min=16384,           # minimum FFT histogram bins (accuracy ↑ with G)
-    use_richardson=True,   # Richardson extrapolation on h_crit (30% accuracy gain)
-    direct_n_max=25_000,   # use direct-KDE (no histogram) for n ≤ this
-    direct_M=2048,         # direct-KDE evaluation grid size
-    use_compile=False,     # infrastructure flag; use TrainingLayer for compile
-    safe_backward=False,   # clamp IFT denominator near bifurcations
+    target_modes=1,           # target number of modes (default 1)
+    use_fft=True,             # FFT path for n > 50K (default True)
+    max_n_exact=None,         # sketch above this n (None = always exact)
+    G_min=16384,              # minimum FFT histogram bins (accuracy ↑ with G)
+    use_richardson="auto",    # Richardson on CPU, off on GPU (30% accuracy gain on CPU)
+    direct_n_max=25_000,      # direct-KDE active only when forward_path='auto'/'direct'
+    direct_M=2048,            # direct-KDE evaluation grid size
+    forward_path='smooth',    # 'smooth' (default, strictly differentiable) |
+                              # 'auto' (direct-KDE at n≤25K, surrogate gradient) |
+                              # 'direct' (force direct-KDE, accuracy benchmarks)
+    safe_backward=False,      # clamp IFT denominator near bifurcations
 )
 ```
 
@@ -343,7 +345,7 @@ By default (`use_richardson=True`), DCB runs a second bisection at G/2=8192 and
 
 - **`compile=True` on MPS**: blocked by float64 in `_refine_hcrit` fallback (fix in v0.1.7)
 - **`compile=True` on CUDA with Python 3.12**: requires torch ≥ 2.4 or Python ≤ 3.11
-- **`gradcheck` with direct-KDE forward**: forward (n ≤ 25K) uses exact KDE; backward uses smooth IFT surrogate — gradcheck will fail by design; use `DCBLayer(direct_n_max=0)` for gradcheck
+- **`gradcheck`**: passes with the default `forward_path='smooth'`; the default is strictly differentiable at all n. Opt into `forward_path='auto'` only for forward-only accuracy benchmarks (surrogate gradient at n≤25K)
 - **n > 100M**: requires streaming histogram (not yet public API); use `max_n_exact=1_000_000` sketch as workaround
 
 ## Confirmed Experimental Results

{diffcb-0.1.7 → diffcb-0.1.9}/README.md

@@ -73,15 +73,17 @@ Cumulative speedup vs v0.1.4 on CPU: 1.1× (100K), 1.7× (1M), **4.2× (10M)**.
 
 ```python
 DCBLayer(
-    target_modes=1,        # target number of modes (default 1)
-    use_fft=True,          # FFT path for n > 50K (default True)
-    max_n_exact=None,      # sketch above this n (None = always exact)
-    G_min=16384,           # minimum FFT histogram bins (accuracy ↑ with G)
-    use_richardson=True,   # Richardson extrapolation on h_crit (30% accuracy gain)
-    direct_n_max=25_000,   # use direct-KDE (no histogram) for n ≤ this
-    direct_M=2048,         # direct-KDE evaluation grid size
-    use_compile=False,     # infrastructure flag; use TrainingLayer for compile
-    safe_backward=False,   # clamp IFT denominator near bifurcations
+    target_modes=1,           # target number of modes (default 1)
+    use_fft=True,             # FFT path for n > 50K (default True)
+    max_n_exact=None,         # sketch above this n (None = always exact)
+    G_min=16384,              # minimum FFT histogram bins (accuracy ↑ with G)
+    use_richardson="auto",    # Richardson on CPU, off on GPU (30% accuracy gain on CPU)
+    direct_n_max=25_000,      # direct-KDE active only when forward_path='auto'/'direct'
+    direct_M=2048,            # direct-KDE evaluation grid size
+    forward_path='smooth',    # 'smooth' (default, strictly differentiable) |
+                              # 'auto' (direct-KDE at n≤25K, surrogate gradient) |
+                              # 'direct' (force direct-KDE, accuracy benchmarks)
+    safe_backward=False,      # clamp IFT denominator near bifurcations
 )
 ```
 
@@ -121,7 +123,7 @@ By default (`use_richardson=True`), DCB runs a second bisection at G/2=8192 and
 
 - **`compile=True` on MPS**: blocked by float64 in `_refine_hcrit` fallback (fix in v0.1.7)
 - **`compile=True` on CUDA with Python 3.12**: requires torch ≥ 2.4 or Python ≤ 3.11
-- **`gradcheck` with direct-KDE forward**: forward (n ≤ 25K) uses exact KDE; backward uses smooth IFT surrogate — gradcheck will fail by design; use `DCBLayer(direct_n_max=0)` for gradcheck
+- **`gradcheck`**: passes with the default `forward_path='smooth'`; the default is strictly differentiable at all n. Opt into `forward_path='auto'` only for forward-only accuracy benchmarks (surrogate gradient at n≤25K)
 - **n > 100M**: requires streaming histogram (not yet public API); use `max_n_exact=1_000_000` sketch as workaround
 
 ## Confirmed Experimental Results

{diffcb-0.1.7 → diffcb-0.1.9}/dcb/__init__.py

@@ -21,4 +21,4 @@ __all__ = [
     "TrainingLayer",
     "anneal_eps_tau", "soft_mode_count_cross", "soft_mode_count",
 ]
-__version__ = "0.1.7"
+__version__ = "0.1.9"

{diffcb-0.1.7 → diffcb-0.1.9}/dcb/fft_kde.py

@@ -137,12 +137,15 @@ def mode_count_from_C(
     if C.numel() == 0:
         return 1  # degenerate single-point distribution
 
+    # Caller must pass C computed with fft_dtype=torch.float64 (complex128).
+    # Float32 histogram errors (~1e-4 relative) create spurious sign changes
+    # near small h_crit that cannot be filtered without killing genuine lobes.
+    # A relative threshold of 1e-12 removes machine-epsilon edge-bin noise
+    # (empty histogram bins at domain boundaries contribute ~eps_f64 to f′).
     K_deriv = 1j * omega * torch.exp(-0.5 * (omega * h) ** 2)
     f_prime = torch.fft.irfft(C * K_deriv, n=N).real[:G]
-    # Exact zeros are measure-zero for smooth KDE on non-degenerate data; strict
-    # inequalities match the masked path in all practical cases while avoiding
-    # one host sync (.any()) and two allocations (nonzero_mask, s) per call.
-    return int(((f_prime[:-1] > 0) & (f_prime[1:] < 0)).sum().item())
+    thresh = f_prime.abs().max() * 1e-12
+    return int(((f_prime[:-1] > thresh) & (f_prime[1:] < -thresh)).sum().item())
 
 
 def mode_count_from_C_batch(
@@ -186,12 +189,15 @@ def mode_count_from_C_batch(
     else:
         h_t = h_batch.to(dtype=omega.dtype, device=omega.device)              # (B,)
 
+    # Caller must pass C in float64 (complex128) — same rationale as mode_count_from_C.
     # Build (B, M) kernel matrix in one vectorised op
     omega_h = omega.unsqueeze(0) * h_t.unsqueeze(1)                       # (B, M)
     K_batch = 1j * omega.unsqueeze(0) * torch.exp(-0.5 * omega_h ** 2)    # (B, M)
     # One batched irfft dispatch instead of B separate calls
-    f_prime_batch = torch.fft.irfft(C.unsqueeze(0) * K_batch, n=N)[:, :G]  # (B, G)
-    return ((f_prime_batch[:, :-1] > 0) & (f_prime_batch[:, 1:] < 0)).sum(dim=1)
+    f_prime_batch = torch.fft.irfft(C.unsqueeze(0) * K_batch, n=N)[:, :G] # (B, G)
+    # Per-bandwidth threshold: remove edge-bin machine-epsilon noise.
+    thresholds = f_prime_batch.abs().amax(dim=1, keepdim=True) * 1e-12    # (B, 1)
+    return ((f_prime_batch[:, :-1] > thresholds) & (f_prime_batch[:, 1:] < -thresholds)).sum(dim=1)
 
 
 def fft_mode_count(

{diffcb-0.1.7 → diffcb-0.1.9}/dcb/layer.py

@@ -14,16 +14,16 @@ the computational graph of the iterative solver and maintaining O(1) memory
 cost relative to the number of solver iterations. Hyperparameters ε and τ
 may be supplied explicitly or computed adaptively via `dcb.utils`.
 
-Forward/backward path mismatch (by design)
--------------------------------------------
-At n ≤ direct_n_max AND forward_path='auto' (default), the FORWARD pass uses
-direct KDE (no histogram) for zero binning bias.  The BACKWARD pass always
-uses the smooth IFT on M̃ (soft mode count) at all n.  These are different
-implicit functions, so ``torch.autograd.gradcheck`` will fail for
-n ≤ direct_n_max with the default settings.  Use ``forward_path='smooth'``
-to force the smooth path in the forward pass — gradcheck will then pass.
-For ML training the mismatch is correct by design: the smooth gradient is
-the appropriate object for gradient descent.
+Strict differentiability
+------------------------
+``forward_path='smooth'`` (the default) forces both the forward and backward
+to use the same smooth M̃ surrogate at all n — ``torch.autograd.gradcheck``
+passes and ∂h_crit/∂X is the exact IFT gradient of the computed h_crit.
+
+``forward_path='auto'`` opts into the direct-KDE forward at n ≤ direct_n_max
+for zero-bias accuracy, but forward and backward then use different implicit
+functions — gradcheck will fail and the gradient is a surrogate.  Only use
+'auto' for forward-only inference benchmarks.
 """
 
 from __future__ import annotations
@@ -189,26 +189,17 @@ class DCBLayer(nn.Module):
     forward_path : str
         Controls forward-pass routing.  One of:
 
-        - ``'auto'`` (default): use direct-KDE for n ≤ direct_n_max, FFT
-          histogram for n > 50K, legacy chunked-KDE for 50K >= n > direct_n_max.
-          This is the current behaviour.
-        - ``'smooth'``: always use the FFT histogram or chunked-KDE path
-          (never direct-KDE).  Internally sets direct_n_max=0.
-          **Use this when you need ``torch.autograd.gradcheck`` to pass**,
-          because it forces forward and backward to use the same smooth M̃.
-        - ``'direct'``: force direct-KDE even for large n.  Slow for large n;
-          intended for accuracy benchmarks.  Internally sets direct_n_max=inf.
-
-        Notes
-        -----
-        Forward/backward path at n <= direct_n_max:
-            The forward pass uses direct KDE (no histogram) for accuracy.
-            The backward pass uses the smooth IFT on M̃ (soft mode count) at all n.
-            These are different implicit functions, so ``torch.autograd.gradcheck``
-            will fail for n <= direct_n_max.  Use ``forward_path='smooth'`` to
-            force the smooth path at all n — gradcheck will then pass.
-            For ML training this mismatch is correct by design: the smooth
-            gradient is the appropriate object for gradient descent.
+        - ``'smooth'`` **(default)**: always use the FFT histogram or
+          chunked-KDE path.  Both forward and backward use the same smooth
+          M̃ surrogate — ``torch.autograd.gradcheck`` passes and gradients
+          are the exact IFT derivatives of the computed h_crit.
+        - ``'auto'``: use direct-KDE for n ≤ direct_n_max (zero histogram
+          bias), FFT for n > 50K, chunked-KDE otherwise.  Forward and
+          backward use different implicit functions at n ≤ direct_n_max,
+          so gradcheck will fail and the gradient is a surrogate.
+          Use only for forward-only inference / accuracy benchmarks.
+        - ``'direct'``: force direct-KDE at all n (accuracy benchmark only;
+          slow for large n; surrogate gradient at all n).
 
     Examples
     --------
@@ -244,7 +235,7 @@ class DCBLayer(nn.Module):
         use_compile: bool = False,
         direct_n_max: int = 25_000,
         direct_M: int = 2048,
-        forward_path: str = 'auto',
+        forward_path: str = 'smooth',
     ):
         super().__init__()
         if forward_path not in ('auto', 'smooth', 'direct'):

{diffcb-0.1.7 → diffcb-0.1.9}/dcb/solver.py

@@ -238,28 +238,36 @@ def find_h_crit_hard(
 
         with torch.no_grad():
             # Worker 1: precomputed C — hoist histogram + rfft out of bisection.
-            # Worker 3: float32 FFT by default — 2× faster; _refine_hcrit uses float64 independently.
+            # Worker 3: float32 FFT for _refine_hcrit (2× faster; refinement is
+            # accuracy-insensitive to histogram dtype).  Mode counting requires
+            # float64 histogram precision: float32 FFT errors (~1e-4 relative)
+            # create spurious sign changes near small h_crit that a relative
+            # threshold cannot remove without also killing genuine small lobes.
             C, omega, _domain = precompute_fft(
                 X, G=G_fft, domain=_domain, pad_factor=pad_factor, fft_dtype=fft_dtype,
             )
+            C_mc, omega_mc, _ = precompute_fft(
+                X, G=G_fft, domain=_domain, pad_factor=pad_factor,
+                fft_dtype=torch.float64,
+            )
 
             # Verify bracket using FFT mode count on full X
-            count_lo = mode_count_from_C(C, omega, h_lo, G_fft, N)
+            count_lo = mode_count_from_C(C_mc, omega_mc, h_lo, G_fft, N)
             if count_lo <= target_modes:
                 h_lo_try = h_lo
                 for _ in range(30):
                     h_lo_try *= 0.5
                     if h_lo_try < 1e-10:
                         break
-                    if mode_count_from_C(C, omega, h_lo_try, G_fft, N) > target_modes:
+                    if mode_count_from_C(C_mc, omega_mc, h_lo_try, G_fft, N) > target_modes:
                         h_lo = h_lo_try
                         break
 
-            count_hi = mode_count_from_C(C, omega, h_hi, G_fft, N)
+            count_hi = mode_count_from_C(C_mc, omega_mc, h_hi, G_fft, N)
             if count_hi > target_modes:
                 for _ in range(30):
                     h_hi *= 2.0
-                    if mode_count_from_C(C, omega, h_hi, G_fft, N) <= target_modes:
+                    if mode_count_from_C(C_mc, omega_mc, h_hi, G_fft, N) <= target_modes:
                         break
 
             # Compile-friendly trisection: lo/hi are 0-d tensors, no .item()
@@ -267,8 +275,8 @@ def find_h_crit_hard(
             # than enough for any bracket).  torch.where replaces the Python
             # if/elif/else so the loop body is a pure tensor computation that
             # torch.compile(mode="reduce-overhead") can trace and replay.
-            _dtype = omega.dtype
-            _dev   = C.device
+            _dtype = omega_mc.dtype
+            _dev   = C_mc.device
             lo_t = torch.tensor(h_lo, dtype=_dtype, device=_dev)
             hi_t = torch.tensor(h_hi, dtype=_dtype, device=_dev)
             _target = torch.tensor(target_modes, dtype=torch.long, device=_dev)
@@ -277,7 +285,7 @@ def find_h_crit_hard(
                 h1 = lo_t + width * (1.0 / 3.0)
                 h2 = lo_t + width * (2.0 / 3.0)
                 counts = mode_count_from_C_batch(
-                    C, omega, torch.stack([h1, h2]), G_fft, N
+                    C_mc, omega_mc, torch.stack([h1, h2]), G_fft, N
                 )
                 c1 = counts[0]
                 c2 = counts[1]

{diffcb-0.1.7 → diffcb-0.1.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "diffcb"
-version = "0.1.7"
+version = "0.1.9"
 description = "Differentiable Critical Bandwidth: Silverman's modality test as a differentiable PyTorch layer with IFT backward pass."
 readme = "README.md"
 license = { file = "LICENSE" }

{diffcb-0.1.7 → diffcb-0.1.9}/tests/test_gradcheck.py

@@ -17,37 +17,29 @@ from dcb.layer import DCBLayer
 # ---------------------------------------------------------------------------
 
 def test_gradcheck_smooth_path():
-    """gradcheck passes when forward_path='smooth' forces smooth M̃ at all n.
-
-    With forward_path='smooth', direct_n_max is set to 0 internally, so the
-    forward pass uses the same chunked-KDE path as the IFT backward (both use
-    the smooth M̃ without direct-KDE).  The forward and backward are consistent
-    implicit functions, so gradcheck passes.
-
-    Tolerances are intentionally loose (atol=0.05, rtol=0.2) because:
-    1. Hard bisection finds h_crit by discrete mode-count steps, introducing
-       quantisation noise of ~O(bisection_tol) in h_crit.
-    2. The IFT backward uses smooth M̃ evaluated at this h_crit, which is
-       not perfectly aligned with the bisection steps.
-    3. These two effects cause O(1%) discrepancies between the analytical
-       and numerical Jacobians — well within the intended ML-training use case,
-       but requiring loose gradcheck tolerances to pass reliably.
+    """gradcheck passes with the default DCBLayer (forward_path='smooth').
+
+    forward_path='smooth' (the default since v0.1.7) forces both the forward
+    pass and the IFT backward to use the same smooth M̃ surrogate — they are
+    the same implicit function, so gradcheck is internally consistent.
+
+    Tolerances are loose (atol=0.05, rtol=0.2) because the hard bisection
+    root-finder introduces O(1%) quantisation noise between the analytical
+    IFT gradient and the finite-difference Jacobian.  This is the expected
+    residual for the discrete-step bisection and does not affect ML training.
     """
     torch.manual_seed(42)
     X = torch.cat([torch.randn(30) - 1.0, torch.randn(30) + 1.0]).double()
     X.requires_grad_(True)
+    # Default forward_path='smooth' — strictly differentiable at all n
     layer = DCBLayer(
-        use_fft=False,           # use chunked-KDE (smooth) at small n
-        forward_path='smooth',   # disable direct-KDE routing; sets direct_n_max=0
-        use_richardson=False,    # Richardson adds a second backward; skip for gradcheck
+        use_fft=False,
+        use_richardson=False,   # skip Richardson for gradcheck clarity
     )
 
-    # eps=1e-3 for finite differences; atol/rtol are loose because the smooth
-    # IFT gradient and FD Jacobian can differ by ~1–5% due to bisection
-    # quantisation — verified reliable across 20 seeds.
     result = torch.autograd.gradcheck(layer, (X,), eps=1e-3, atol=0.05, rtol=0.2,
                                       raise_exception=True)
-    assert result, "gradcheck failed with forward_path='smooth'"
+    assert result, "gradcheck failed with default DCBLayer (forward_path='smooth')"
 
 
 # ---------------------------------------------------------------------------

{diffcb-0.1.7 → diffcb-0.1.9}/tests/test_layer.py

@@ -121,24 +121,27 @@ def test_dcblayer_state_dict():
 
 @pytest.mark.xfail(
     reason=(
-        "IFT gradient is an approximation (soft M̃_cross at h_crit found by hard bisection). "
-        "gradcheck at atol=1e-3 is too strict for the soft/hard mismatch at small n. "
-        "Qualitative correctness verified in test_ift_gradient_matches_finite_diff."
+        "Hard bisection introduces quantisation noise even with forward_path='smooth'. "
+        "atol=1e-3 is too strict for the bisection step-function discretisation. "
+        "Qualitative correctness verified in test_ift_gradient_matches_finite_diff; "
+        "loose-tolerance gradcheck passes in tests/test_gradcheck.py."
     ),
     strict=False,
 )
 def test_dcblayer_gradcheck():
     """torch.autograd.gradcheck with double precision, eps=1e-4, atol=1e-3.
 
-    Uses bimodal X with n=30 (small for speed). This is the strictest criterion.
-    gradcheck verifies that the custom IFT backward matches the numerical Jacobian.
+    Uses bimodal X with n=30 (small for speed).  Default forward_path='smooth'
+    means forward and backward use the same M̃ surrogate — the remaining xfail
+    is due to bisection quantisation noise (step-function root-finding), not a
+    forward/backward path mismatch.  Loose-tolerance gradcheck passes separately.
     """
     torch.manual_seed(42)
     n = 30
     X_base = torch.cat([torch.randn(15) - 1.0, torch.randn(15) + 1.0])
     X = X_base.double().requires_grad_(True)
 
-    layer = DCBLayer(target_modes=1, G=64)
+    layer = DCBLayer(target_modes=1, G=64)  # default forward_path='smooth'
 
     def fn(x):
         return layer(x)

diffcb-0.1.9/v018_local_bench.py

@@ -0,0 +1,394 @@
+"""
+v018_local_bench.py
+Comprehensive benchmark for diffcb v0.1.8 (forward_path='smooth' default).
+Produces 3 CSV files and prints summary tables.
+"""
+
+import os
+import time
+import math
+import subprocess
+import tempfile
+import statistics
+import csv
+
+import torch
+from dcb import DCBLayer
+
+RESULTS_DIR = "/Users/h/Downloads/DCB-workspace/02_projects/01_dcb_proposal/04_analysis/results"
+os.makedirs(RESULTS_DIR, exist_ok=True)
+
+SPEED_NS = [1_000, 2_000, 5_000, 10_000, 25_000, 50_000, 100_000,
+            500_000, 1_000_000, 5_000_000, 10_000_000]
+ACCURACY_NS = [1_000, 5_000, 10_000, 25_000, 50_000, 100_000, 500_000, 1_000_000]
+
+DEVICES = ['cpu']
+if torch.backends.mps.is_available():
+    DEVICES.append('mps')
+    print("MPS is available — will benchmark both CPU and MPS.")
+else:
+    print("MPS not available — benchmarking CPU only.")
+
+R_BINARY = '/usr/local/bin/Rscript'
+
+
+# ─────────────────────────────────────────────────────────
+# Calibration: T_fft_one_ms per device
+# ─────────────────────────────────────────────────────────
+
+def calibrate_fft(device: str) -> float:
+    """Return mean time in ms for one rfft(ones(16384)) call."""
+    x = torch.ones(16384, dtype=torch.float32, device=device)
+    WARMUP = 500
+    TIMED = 5000
+
+    # Warm-up
+    for _ in range(WARMUP):
+        torch.fft.rfft(x)
+
+    if device == 'mps':
+        torch.mps.synchronize()
+        t0 = time.perf_counter()
+        for _ in range(TIMED):
+            torch.fft.rfft(x)
+        torch.mps.synchronize()
+        t1 = time.perf_counter()
+    else:
+        t0 = time.perf_counter()
+        for _ in range(TIMED):
+            torch.fft.rfft(x)
+        t1 = time.perf_counter()
+
+    total_ms = (t1 - t0) * 1000.0
+    return total_ms / TIMED
+
+
+print("\n=== Calibrating FFT units ===")
+T_fft = {}
+for dev in DEVICES:
+    T_fft[dev] = calibrate_fft(dev)
+    print(f"  {dev}: T_fft_one_ms = {T_fft[dev]:.6f} ms")
+
+
+# ─────────────────────────────────────────────────────────
+# Part 1 — Speed benchmark
+# ─────────────────────────────────────────────────────────
+
+print("\n=== Part 1: Speed Benchmark ===")
+speed_rows = []
+
+for device in DEVICES:
+    # Build a shared DCBLayer for this device (reuse across n — it's stateless)
+    layer = DCBLayer()
+    if device == 'mps':
+        layer = layer.to(device)
+
+    T_fft_one_ms = T_fft[device]
+
+    for n in SPEED_NS:
+        if n >= 5_000_000 and device == 'mps':
+            print(f"  [mps, n={n:,}] — skipping (too large for MPS RAM guard)")
+            speed_rows.append({
+                'device': device, 'n': n,
+                't_median_ms': float('nan'), 't_mean_ms': float('nan'),
+                't_std_ms': float('nan'), 'throughput_ns': float('nan'),
+                'fft_norm_cost': float('nan'), 'T_fft_one_ms': T_fft_one_ms,
+            })
+            continue
+
+        try:
+            X = torch.randn(n, device=device)
+
+            # 3 warm-up calls
+            for _ in range(3):
+                _ = layer(X)
+            if device == 'mps':
+                torch.mps.synchronize()
+
+            # 15 timed calls
+            times_ms = []
+            REPS = 15
+            for _ in range(REPS):
+                if device == 'mps':
+                    torch.mps.synchronize()
+                    t0 = time.perf_counter()
+                    layer(X)
+                    torch.mps.synchronize()
+                    t1 = time.perf_counter()
+                else:
+                    t0 = time.perf_counter()
+                    layer(X)
+                    t1 = time.perf_counter()
+                times_ms.append((t1 - t0) * 1000.0)
+
+            t_median_ms = statistics.median(times_ms)
+            t_mean_ms = statistics.mean(times_ms)
+            t_std_ms = statistics.stdev(times_ms) if len(times_ms) > 1 else 0.0
+            throughput_ns = n / (t_median_ms / 1000.0)
+            fft_norm_cost = t_median_ms / T_fft_one_ms
+
+            speed_rows.append({
+                'device': device, 'n': n,
+                't_median_ms': t_median_ms, 't_mean_ms': t_mean_ms,
+                't_std_ms': t_std_ms, 'throughput_ns': throughput_ns,
+                'fft_norm_cost': fft_norm_cost, 'T_fft_one_ms': T_fft_one_ms,
+            })
+            print(f"  [{device}, n={n:>10,}] median={t_median_ms:.3f}ms  tput={throughput_ns/1e6:.2f}M/s  fft_cost={fft_norm_cost:.1f}")
+
+        except RuntimeError as e:
+            print(f"  [{device}, n={n:,}] RuntimeError (OOM?): {e}")
+            speed_rows.append({
+                'device': device, 'n': n,
+                't_median_ms': float('nan'), 't_mean_ms': float('nan'),
+                't_std_ms': float('nan'), 'throughput_ns': float('nan'),
+                'fft_norm_cost': float('nan'), 'T_fft_one_ms': T_fft_one_ms,
+            })
+
+# Write speed CSV
+speed_csv = os.path.join(RESULTS_DIR, 'v018_local_speed.csv')
+speed_fields = ['device', 'n', 't_median_ms', 't_mean_ms', 't_std_ms',
+                'throughput_ns', 'fft_norm_cost', 'T_fft_one_ms']
+with open(speed_csv, 'w', newline='') as f:
+    w = csv.DictWriter(f, fieldnames=speed_fields)
+    w.writeheader()
+    w.writerows(speed_rows)
+print(f"\nSpeed CSV saved: {speed_csv}")
+
+
+# ─────────────────────────────────────────────────────────
+# Helper: call R bw.crit on a tensor
+# ─────────────────────────────────────────────────────────
+
+def r_bwcrit(X_tensor: torch.Tensor) -> float:
+    """Write tensor to temp CSV and call R bw.crit. Returns NaN on failure."""
+    try:
+        with tempfile.NamedTemporaryFile(suffix='.csv', mode='w', delete=False) as f:
+            f.write('x\n')
+            for v in X_tensor.tolist():
+                f.write(f'{v:.10f}\n')
+            fname = f.name
+        result = subprocess.run(
+            [R_BINARY, '--vanilla', '-e',
+             f'library(multimode); x<-read.csv("{fname}")$x; cat(bw.crit(x,mod0=1L))'],
+            capture_output=True, text=True, timeout=300
+        )
+        os.unlink(fname)
+        if result.returncode != 0 or not result.stdout.strip():
+            print(f"  WARNING: R call failed. stderr: {result.stderr.strip()[:200]}")
+            return float('nan')
+        return float(result.stdout.strip())
+    except Exception as e:
+        print(f"  WARNING: R call exception: {e}")
+        try:
+            os.unlink(fname)
+        except Exception:
+            pass
+        return float('nan')
+
+
+# ─────────────────────────────────────────────────────────
+# Part 2 — Accuracy: Independent-sample
+# ─────────────────────────────────────────────────────────
+
+print("\n=== Part 2: Accuracy — Independent-sample ===")
+indep_rows = []
+
+for n in ACCURACY_NS:
+    for seed in range(20):
+        torch.manual_seed(seed)
+        X = torch.randn(n)
+
+        # DCB
+        try:
+            layer_cpu = DCBLayer()
+            h_dcb = layer_cpu(X).item()
+        except Exception as e:
+            print(f"  WARNING: DCB failed n={n}, seed={seed}: {e}")
+            h_dcb = float('nan')
+
+        # R (skip if n > 1_000_000)
+        if n > 1_000_000:
+            h_r = float('nan')
+            err_pct = float('nan')
+        else:
+            h_r = r_bwcrit(X)
+            if math.isnan(h_r) or math.isnan(h_dcb):
+                err_pct = float('nan')
+            else:
+                err_pct = abs(h_dcb - h_r) / h_r * 100.0
+
+        indep_rows.append({'n': n, 'seed': seed, 'h_dcb': h_dcb,
+                           'h_r': h_r, 'err_pct': err_pct})
+
+    valid = [r for r in indep_rows if r['n'] == n and not math.isnan(r.get('err_pct', float('nan')))]
+    if valid:
+        mean_e = statistics.mean(r['err_pct'] for r in valid)
+        print(f"  n={n:>9,}: mean_err={mean_e:.4f}% over {len(valid)} seeds with R comparison")
+    else:
+        dcb_vals = [r['h_dcb'] for r in indep_rows if r['n'] == n]
+        print(f"  n={n:>9,}: no R comparison (skipped); h_dcb range [{min(dcb_vals):.4f}, {max(dcb_vals):.4f}]")
+
+indep_csv = os.path.join(RESULTS_DIR, 'v018_local_accuracy_indep.csv')
+with open(indep_csv, 'w', newline='') as f:
+    w = csv.DictWriter(f, fieldnames=['n', 'seed', 'h_dcb', 'h_r', 'err_pct'])
+    w.writeheader()
+    w.writerows(indep_rows)
+print(f"\nIndep accuracy CSV saved: {indep_csv}")
+
+
+# ─────────────────────────────────────────────────────────
+# Part 3 — Accuracy: Same-sample
+# ─────────────────────────────────────────────────────────
+
+print("\n=== Part 3: Accuracy — Same-sample ===")
+same_rows = []
+
+SAME_NS = [1_000, 5_000, 10_000, 25_000, 50_000, 100_000, 500_000, 1_000_000]
+
+for n in SAME_NS:
+    for seed in range(10):
+        torch.manual_seed(seed)
+        X = torch.randn(n)
+
+        # Write to temp CSV once — both DCB and R use same data
+        try:
+            with tempfile.NamedTemporaryFile(suffix='.csv', mode='w', delete=False) as f:
+                f.write('x\n')
+                for v in X.tolist():
+                    f.write(f'{v:.10f}\n')
+                fname = f.name
+
+            # DCB
+            try:
+                layer_cpu = DCBLayer()
+                h_dcb = layer_cpu(X).item()
+            except Exception as e:
+                print(f"  WARNING: DCB failed n={n}, seed={seed}: {e}")
+                h_dcb = float('nan')
+
+            # R (using same file)
+            try:
+                result = subprocess.run(
+                    [R_BINARY, '--vanilla', '-e',
+                     f'library(multimode); x<-read.csv("{fname}")$x; cat(bw.crit(x,mod0=1L))'],
+                    capture_output=True, text=True, timeout=300
+                )
+                if result.returncode != 0 or not result.stdout.strip():
+                    print(f"  WARNING: R call failed n={n}, seed={seed}. stderr: {result.stderr.strip()[:200]}")
+                    h_r = float('nan')
+                else:
+                    h_r = float(result.stdout.strip())
+            except Exception as e:
+                print(f"  WARNING: R call exception n={n}, seed={seed}: {e}")
+                h_r = float('nan')
+
+            os.unlink(fname)
+
+        except Exception as e:
+            print(f"  WARNING: Temp file error n={n}, seed={seed}: {e}")
+            h_dcb = float('nan')
+            h_r = float('nan')
+
+        if math.isnan(h_r) or math.isnan(h_dcb):
+            err_pct = float('nan')
+        else:
+            err_pct = abs(h_dcb - h_r) / h_r * 100.0
+
+        same_rows.append({'n': n, 'seed': seed, 'h_dcb': h_dcb,
+                          'h_r': h_r, 'err_pct': err_pct})
+
+    valid = [r for r in same_rows if r['n'] == n and not math.isnan(r.get('err_pct', float('nan')))]
+    if valid:
+        mean_e = statistics.mean(r['err_pct'] for r in valid)
+        print(f"  n={n:>9,}: mean_err={mean_e:.4f}% over {len(valid)} seeds")
+    else:
+        print(f"  n={n:>9,}: no valid comparisons")
+
+same_csv = os.path.join(RESULTS_DIR, 'v018_local_accuracy_same.csv')
+with open(same_csv, 'w', newline='') as f:
+    w = csv.DictWriter(f, fieldnames=['n', 'seed', 'h_dcb', 'h_r', 'err_pct'])
+    w.writeheader()
+    w.writerows(same_rows)
+print(f"\nSame-sample accuracy CSV saved: {same_csv}")
+
+
+# ─────────────────────────────────────────────────────────
+# Summary Tables
+# ─────────────────────────────────────────────────────────
+
+def fmt_float(x, fmt='.3f'):
+    if math.isnan(x):
+        return 'N/A'
+    return format(x, fmt)
+
+print("\n" + "="*110)
+print("SUMMARY")
+print("="*110)
+
+# Calibration
+print("\n--- Calibration Units ---")
+print(f"{'Device':<8} | {'T_fft_one_ms':>14}")
+print("-" * 28)
+for dev in DEVICES:
+    print(f"{dev:<8} | {T_fft[dev]:>14.6f}")
+
+# Speed table
+print("\n--- Speed Benchmark ---")
+col_w = 14
+hdr = (f"{'n':>12} | {'CPU t_med(ms)':>{col_w}} | {'CPU fft_cost':>{col_w}} | "
+       f"{'CPU n/s':>{col_w}}")
+if 'mps' in DEVICES:
+    hdr += (f" | {'MPS t_med(ms)':>{col_w}} | {'MPS fft_cost':>{col_w}} | "
+            f"{'MPS n/s':>{col_w}}")
+print(hdr)
+print("-" * len(hdr))
+
+speed_by_n = {}
+for r in speed_rows:
+    key = (r['n'], r['device'])
+    speed_by_n[key] = r
+
+for n in SPEED_NS:
+    cpu_r = speed_by_n.get((n, 'cpu'), {})
+    cpu_med = fmt_float(cpu_r.get('t_median_ms', float('nan')))
+    cpu_fft = fmt_float(cpu_r.get('fft_norm_cost', float('nan')), '.1f')
+    cpu_tput_raw = cpu_r.get('throughput_ns', float('nan'))
+    cpu_tput = 'N/A' if math.isnan(cpu_tput_raw) else f"{cpu_tput_raw/1e6:.2f}M/s"
+
+    line = f"{n:>12,} | {cpu_med:>{col_w}} | {cpu_fft:>{col_w}} | {cpu_tput:>{col_w}}"
+
+    if 'mps' in DEVICES:
+        mps_r = speed_by_n.get((n, 'mps'), {})
+        mps_med = fmt_float(mps_r.get('t_median_ms', float('nan')))
+        mps_fft = fmt_float(mps_r.get('fft_norm_cost', float('nan')), '.1f')
+        mps_tput_raw = mps_r.get('throughput_ns', float('nan'))
+        mps_tput = 'N/A' if math.isnan(mps_tput_raw) else f"{mps_tput_raw/1e6:.2f}M/s"
+        line += f" | {mps_med:>{col_w}} | {mps_fft:>{col_w}} | {mps_tput:>{col_w}}"
+
+    print(line)
+
+# Accuracy table
+print("\n--- Accuracy (mean % error vs R bw.crit) ---")
+print(f"{'n':>12} | {'Indep mean_err%':>16} | {'Indep std_err%':>15} | {'Same mean_err%':>15} | {'Same std_err%':>14}")
+print("-" * 90)
+
+def acc_stats(rows, n_val):
+    valid = [r['err_pct'] for r in rows if r['n'] == n_val and not math.isnan(r.get('err_pct', float('nan')))]
+    if not valid:
+        return float('nan'), float('nan')
+    mean_e = statistics.mean(valid)
+    std_e = statistics.stdev(valid) if len(valid) > 1 else 0.0
+    return mean_e, std_e
+
+for n in ACCURACY_NS:
+    indep_mean, indep_std = acc_stats(indep_rows, n)
+    same_mean, same_std = acc_stats(same_rows, n)
+    print(f"{n:>12,} | {fmt_float(indep_mean, '.4f'):>16} | {fmt_float(indep_std, '.4f'):>15} | "
+          f"{fmt_float(same_mean, '.4f'):>15} | {fmt_float(same_std, '.4f'):>14}")
+
+print("\n" + "="*110)
+print("Benchmark complete.")
+print(f"CSVs saved to: {RESULTS_DIR}")
+print(f"  Speed:          v018_local_speed.csv")
+print(f"  Accuracy indep: v018_local_accuracy_indep.csv")
+print(f"  Accuracy same:  v018_local_accuracy_same.csv")