diffcb 0.1.9__tar.gz → 0.1.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffcb
-Version: 0.1.9
+Version: 0.1.10
 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

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

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

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

@@ -361,8 +361,20 @@ def _refine_hcrit(
         y_mid = fprime(h_mid)[j].item()
         y_hi  = fp_hi_[j].item()
 
-        # Fit quadratic y = a*h² + b*h + c through the three (h, y) pairs
-        # and solve for the root in [ref_lo, ref_hi].
+        # Square-root model: near a saddle-node bifurcation, f'_peak ∝ (h_crit − h),
+        # so f'²_peak is linear in h.  Fit y² = a + b·h through 3 points and solve
+        # y²=0 → h_crit = −a/b.  More accurate than quadratic for Gaussian/unimodal data.
+        y_sq = [y_lo ** 2, y_mid ** 2, y_hi ** 2]
+        # Ensure y_lo >= 0 (it should be positive by candidate_mask selection)
+        if y_lo > 0:
+            sqrt_coeffs = np.polyfit([ref_lo, h_mid, ref_hi], y_sq, 1)  # degree-1 fit
+            b_sqrt, a_sqrt = sqrt_coeffs[0], sqrt_coeffs[1]
+            if b_sqrt != 0:
+                sqrt_root = -a_sqrt / b_sqrt
+                if ref_lo <= sqrt_root <= ref_hi:
+                    return float(sqrt_root)
+
+        # Fallback: original quadratic fit
         coeffs = np.polyfit([ref_lo, h_mid, ref_hi], [y_lo, y_mid, y_hi], 2)
         roots = np.roots(coeffs)
         real_roots = [

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

@@ -231,7 +231,13 @@ def find_h_crit_hard(
             lo_domain = X.min().item() - 3 * sigma
             hi_domain = X.max().item() + 3 * sigma
             data_range = hi_domain - lo_domain
-        G_fft = adaptive_fft_G(data_range, h_hi, G_min=G_min)
+        # Scale G_min with n^0.4 to keep h_crit/bin_width stable as h_crit shrinks.
+        # For Gaussian-regime data h_crit ~ n^{-1/5}, bin_width ~ data_range/G_min,
+        # so ratio h_crit/bin_width ~ n^{-1/5} * G_min / data_range.  Scaling G_min
+        # by n^0.4 keeps this ratio non-decreasing in n without hurting small-n speed.
+        n_fft = X.shape[0]
+        G_min_eff = min(max(G_min, int(G_min * (n_fft / 100_000) ** 0.4)), 262144)
+        G_fft = adaptive_fft_G(data_range, h_hi, G_min=G_min_eff)
         _domain = (lo_domain, hi_domain)
         pad_factor = 2  # Worker 5: pad_factor=2 (was 4) — safe for h ≤ 3σ, halves irfft size
         N = pad_factor * G_fft
@@ -307,10 +313,13 @@ def find_h_crit_hard(
             # to locate h_crit below the bin-width precision limit.
             # Worker 23-4: pass C and omega from bisection to avoid duplicate O(n)
             # histogram + rfft inside _refine_hcrit (saves ~80 ms at n=10M).
+            # Fix: use float64 C_mc/omega_mc instead of float32 C/omega — near h_crit
+            # the disappearing lobe peak is ~1e-3×max|f′|; float32 noise (~1e-4×max|f′|)
+            # gave SNR≈10 → ~0.10% error for Gaussian data.  C_mc is already computed.
             from dcb.fft_kde import _refine_hcrit
             h_crit = _refine_hcrit(
                 X, lo_val, hi_val, G_fft, _domain, target_modes,
-                C_external=C, omega_external=omega,
+                C_external=C_mc, omega_external=omega_mc,
                 fft_dtype=fft_dtype,
             )
 
@@ -327,6 +336,13 @@ def find_h_crit_hard(
                             X, G=G_half, domain=_domain,
                             pad_factor=pad_factor, fft_dtype=fft_dtype,
                         )
+                        # Mirror of v0.1.9 main-path fix: compute float64 version of
+                        # C_half so that the Richardson trisection and _refine_hcrit
+                        # call have float64 SNR, eliminating float32 noise in h_crit_half.
+                        C_half_mc, omega_half_mc, _ = precompute_fft(
+                            X, G=G_half, domain=_domain,
+                            pad_factor=pad_factor, fft_dtype=torch.float64,
+                        )
                         N_half = pad_factor * G_half
 
                         # Narrow bracket around the fine-grid h_crit.
@@ -334,8 +350,8 @@ def find_h_crit_hard(
                         h_hi_r = h_crit * 1.05
 
                         def _bracket_valid(lo_r, hi_r):
-                            c_lo = mode_count_from_C(C_half, omega_half, lo_r, G_half, N_half)
-                            c_hi = mode_count_from_C(C_half, omega_half, hi_r, G_half, N_half)
+                            c_lo = mode_count_from_C(C_half_mc, omega_half_mc, lo_r, G_half, N_half)
+                            c_hi = mode_count_from_C(C_half_mc, omega_half_mc, hi_r, G_half, N_half)
                             return (c_lo > target_modes) and (c_hi <= target_modes)
 
                         valid = _bracket_valid(h_lo_r, h_hi_r)
@@ -346,8 +362,9 @@ def find_h_crit_hard(
 
                         if valid:
                             # Compile-friendly trisection for Richardson half-grid.
-                            _dtype_r = omega_half.dtype
-                            _dev_r   = C_half.device
+                            # Use float64 C_half_mc/omega_half_mc for SNR.
+                            _dtype_r = omega_half_mc.dtype
+                            _dev_r   = C_half_mc.device
                             lo_rt = torch.tensor(h_lo_r, dtype=_dtype_r, device=_dev_r)
                             hi_rt = torch.tensor(h_hi_r, dtype=_dtype_r, device=_dev_r)
                             _target_r = torch.tensor(target_modes, dtype=torch.long, device=_dev_r)
@@ -356,7 +373,7 @@ def find_h_crit_hard(
                                 h1_r = lo_rt + width_r * (1.0 / 3.0)
                                 h2_r = lo_rt + width_r * (2.0 / 3.0)
                                 counts_r = mode_count_from_C_batch(
-                                    C_half, omega_half,
+                                    C_half_mc, omega_half_mc,
                                     torch.stack([h1_r, h2_r]), G_half, N_half,
                                 )
                                 c1_r = counts_r[0]
@@ -373,7 +390,7 @@ def find_h_crit_hard(
 
                             h_crit_half = _refine_hcrit(
                                 X, lo_r, hi_r, G_half, _domain, target_modes,
-                                C_external=C_half, omega_external=omega_half,
+                                C_external=C_half_mc, omega_external=omega_half_mc,
                                 fft_dtype=fft_dtype,
                             )
 

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

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