softopt 0.6.2__tar.gz → 0.6.4__tar.gz

{softopt-0.6.2/softopt.egg-info → softopt-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: softopt
-Version: 0.6.2
+Version: 0.6.4
 Summary: A standalone optimizer for problems with a known computation graph, built on Klein–Maimon soft-number calculus
 Author: Ido Angel
 License: MIT
@@ -120,8 +120,18 @@ Your model needs to be built from arithmetic and the elementary functions the so
 
 The one thing to avoid is converting a traced value back to a plain number mid-model — `float(x)`, or `np.array(params)` on the parameter list, both silently discard the derivative. `soft_compile`'s verification catches this and says so.
 
+**Parameter scale.** SoftOpt's correction moves each parameter by at most 0.5 per step, a natural size for angles and other parameters of order 1. If your parameters live on a very different scale (pixel offsets of 0.03, prices in the thousands), rescale them to roughly ±1, or set the bound to match: `SoftOpt(n, g_delta, lr=..., newton_lo=-b, newton_hi=b)`.
+
 If you'd rather write the derivative function yourself — because your model lives in a simulator SoftOpt can't trace, or because you want the speed of a hand-tuned implementation — pass any `g_delta(theta, delta)` that returns the exact directional derivative, and skip `soft_compile` entirely.
 
+### Exact curvature (new in 0.6.4)
+
+The Newton correction needs two numbers along the probe direction: the slope D1 and the curvature D2. Since 0.6.4 both come from **one pass of your model on nested soft numbers**, with no step size. Each parameter enters as `θ + δ·ε₁ + δ·ε₂`, where each soft axis obeys the book's `ε² = 0`; the mixed `ε₁ε₂` part of the result is D2 exactly (Lemma 6.1 applied twice). `soft_compile` sets this up for you, and `SoftOpt` uses it automatically.
+
+A hand-written `g_delta` can opt in the same way by carrying an attribute `g_delta.d1_d2 = lambda theta, delta: (D1, D2)`. Without it, D2 is a central finite difference of your exact `g_delta` (`h_fd`, the 0.6.3 behaviour, unchanged). `exact_d2=False` forces the finite difference.
+
+On the H4 benchmark (FakeFez, 10 seeds) the exact-curvature engine (`benchmarks/vqe/soft_su2_exact.py`, `h4_exact_d2.py`) gives the same result as the published one: 400 vs 409 mHa at step 100 (p=0.56), both 10/10 against Adam with 67% of the gap closed. `examples/soft_tensor_demo.py` shows that the same nested construction on tensors reproduces SoftOptTorch's nested `torch.func.jvp` to rounding (4e-16).
+
 ## Where the slope comes from: `slope="model"` or `slope="measured"`
 
 Every correction is a Newton step, `-slope / curvature`, taken along one direction. The curvature always comes from your model. The slope has two possible sources:
@@ -204,6 +214,16 @@ All results below use IBM's `FakeFez` noise model via Qiskit + Aer, or realistic
 
 Both run SoftOpt with its default settings on IBM's `FakeFez` noise model: `benchmarks/vqe/h4_real_molecule.py`, `benchmarks/vqe/h2_vs_cobyla.py`.
 
+**Quantum machine learning**
+
+| Test | Baseline | Result | Win rate |
+|---|---|---|---|
+| Variational quantum classifier (Iris, 4 qubits, 24 parameters), same budget of 300 readings, 20 seeds | Adam | 25% lower training loss; test accuracy on the device 70.0% vs 66.3% | 20/20 (loss), 15/20 + 3 ties (accuracy) |
+| Variational quantum classifier (breast cancer, 8 qubits, 48 parameters), same budget, 10 seeds | Adam | 6% lower training loss; test accuracy on the device 90.0% vs 88.3% | 10/10 (loss), 7/10 + 2 ties (accuracy) |
+| Same two classifiers | COBYLA | lower training loss (Iris 16/20, cancer 10/10); test accuracy tied | 16/20, 10/10 (loss) |
+
+`benchmarks/qml/vqc.py --dataset iris|cancer`
+
 **Quantum control**
 
 | Domain | Improvement | Win rate |

{softopt-0.6.2 → softopt-0.6.4}/README.md

@@ -94,8 +94,18 @@ Your model needs to be built from arithmetic and the elementary functions the so
 
 The one thing to avoid is converting a traced value back to a plain number mid-model — `float(x)`, or `np.array(params)` on the parameter list, both silently discard the derivative. `soft_compile`'s verification catches this and says so.
 
+**Parameter scale.** SoftOpt's correction moves each parameter by at most 0.5 per step, a natural size for angles and other parameters of order 1. If your parameters live on a very different scale (pixel offsets of 0.03, prices in the thousands), rescale them to roughly ±1, or set the bound to match: `SoftOpt(n, g_delta, lr=..., newton_lo=-b, newton_hi=b)`.
+
 If you'd rather write the derivative function yourself — because your model lives in a simulator SoftOpt can't trace, or because you want the speed of a hand-tuned implementation — pass any `g_delta(theta, delta)` that returns the exact directional derivative, and skip `soft_compile` entirely.
 
+### Exact curvature (new in 0.6.4)
+
+The Newton correction needs two numbers along the probe direction: the slope D1 and the curvature D2. Since 0.6.4 both come from **one pass of your model on nested soft numbers**, with no step size. Each parameter enters as `θ + δ·ε₁ + δ·ε₂`, where each soft axis obeys the book's `ε² = 0`; the mixed `ε₁ε₂` part of the result is D2 exactly (Lemma 6.1 applied twice). `soft_compile` sets this up for you, and `SoftOpt` uses it automatically.
+
+A hand-written `g_delta` can opt in the same way by carrying an attribute `g_delta.d1_d2 = lambda theta, delta: (D1, D2)`. Without it, D2 is a central finite difference of your exact `g_delta` (`h_fd`, the 0.6.3 behaviour, unchanged). `exact_d2=False` forces the finite difference.
+
+On the H4 benchmark (FakeFez, 10 seeds) the exact-curvature engine (`benchmarks/vqe/soft_su2_exact.py`, `h4_exact_d2.py`) gives the same result as the published one: 400 vs 409 mHa at step 100 (p=0.56), both 10/10 against Adam with 67% of the gap closed. `examples/soft_tensor_demo.py` shows that the same nested construction on tensors reproduces SoftOptTorch's nested `torch.func.jvp` to rounding (4e-16).
+
 ## Where the slope comes from: `slope="model"` or `slope="measured"`
 
 Every correction is a Newton step, `-slope / curvature`, taken along one direction. The curvature always comes from your model. The slope has two possible sources:
@@ -178,6 +188,16 @@ All results below use IBM's `FakeFez` noise model via Qiskit + Aer, or realistic
 
 Both run SoftOpt with its default settings on IBM's `FakeFez` noise model: `benchmarks/vqe/h4_real_molecule.py`, `benchmarks/vqe/h2_vs_cobyla.py`.
 
+**Quantum machine learning**
+
+| Test | Baseline | Result | Win rate |
+|---|---|---|---|
+| Variational quantum classifier (Iris, 4 qubits, 24 parameters), same budget of 300 readings, 20 seeds | Adam | 25% lower training loss; test accuracy on the device 70.0% vs 66.3% | 20/20 (loss), 15/20 + 3 ties (accuracy) |
+| Variational quantum classifier (breast cancer, 8 qubits, 48 parameters), same budget, 10 seeds | Adam | 6% lower training loss; test accuracy on the device 90.0% vs 88.3% | 10/10 (loss), 7/10 + 2 ties (accuracy) |
+| Same two classifiers | COBYLA | lower training loss (Iris 16/20, cancer 10/10); test accuracy tied | 16/20, 10/10 (loss) |
+
+`benchmarks/qml/vqc.py --dataset iris|cancer`
+
 **Quantum control**
 
 | Domain | Improvement | Win rate |

{softopt-0.6.2 → softopt-0.6.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "softopt"
-version = "0.6.2"
+version = "0.6.4"
 description = "A standalone optimizer for problems with a known computation graph, built on Klein–Maimon soft-number calculus"
 readme = "README.md"
 license = { text = "MIT" }

{softopt-0.6.2 → softopt-0.6.4}/softopt/__init__.py

@@ -33,4 +33,4 @@ __all__ = [
     "sadd", "sneg", "ssub", "smul", "sinv", "sdiv",
     "spow", "sroot", "ssqrt", "ssin", "scos", "sexp", "slog",
 ]
-__version__ = "0.6.2"
+__version__ = "0.6.4"

{softopt-0.6.2 → softopt-0.6.4}/softopt/compile.py

@@ -61,6 +61,33 @@ def soft_compile(model_fn, n_params=None, verify=True, verify_tol=1e-5):
             )
         return result.a
 
+    def d1_d2(theta, delta):
+        """Exact D1 = f'(theta).delta and D2 = delta^T f''(theta) delta from ONE pass of the model
+        on nested soft numbers: each parameter is t + eps2*d + eps1*d, built as
+        SoftNumber(SoftNumber(0, d), SoftNumber(d, t)). Each axis obeys the book's eps^2 = 0; the
+        mixed eps1*eps2 component of the result is D2 (Lemma 6.1 applied twice). No step size."""
+        soft = [SoftNumber(SoftNumber(0.0, float(d)), SoftNumber(float(d), float(t)))
+                for t, d in zip(theta, delta)]
+        r = model_fn(soft)
+        if not (isinstance(r, SoftNumber) and isinstance(r.a, SoftNumber)):
+            raise TypeError("the model did not propagate nested soft numbers")
+        D1, D2 = float(r.a.b), float(r.a.a)
+        if not (np.isfinite(D1) and np.isfinite(D2)):
+            raise FloatingPointError(f"non-finite slope/curvature ({D1}, {D2}) at this point")
+        return D1, D2
+
+    # Attach the exact second-order path; SoftOpt uses it automatically when present.
+    # If the model cannot carry nested soft numbers, fall back silently to the first-order g_delta.
+    try:
+        _t = np.random.default_rng(1).normal(0.0, 0.5, n_params) if n_params else None
+        if _t is not None:
+            d1, _ = d1_d2(_t, np.ones(n_params))
+            if abs(d1 - g_delta(_t, np.ones(n_params))) > 1e-9 * max(1.0, abs(d1)):
+                raise ValueError
+        g_delta.d1_d2 = d1_d2
+    except Exception:
+        pass
+
     if verify:
         if n_params is None:
             raise ValueError("pass n_params to verify the compiled model, "

{softopt-0.6.2 → softopt-0.6.4}/softopt/numpy_optimizer.py

@@ -8,9 +8,14 @@ known model (circuit, projection, physical law). `soft_compile` generates
 this for you from a model written in ordinary Python.
 
 The correction is a bounded Newton step, t* = -D1 / D2 along a direction delta.
-D2 (the curvature) always comes from your model: a central finite difference
-OF the exact soft-number derivative, with the usual step-size trade-off,
-controlled by h_fd. D1 (the slope) has two possible sources, set by `slope`:
+D2 (the curvature) always comes from your model. When g_delta comes from
+`soft_compile` (or carries a `d1_d2(theta, delta) -> (D1, D2)` attribute), D2 is
+EXACT: one pass of the model on nested soft numbers (two soft axes, each with
+eps^2 = 0; the mixed term is D2) -- no step size. For a hand-written g_delta
+without that attribute, D2 is a central finite difference OF the exact
+soft-number derivative, controlled by h_fd (the 0.6.3 behaviour).
+
+D1 (the slope) has two possible sources, set by `slope`:
 
   slope="model"     (default) D1 is the model's exact directional derivative
                     along a fresh random direction. Robust to very noisy
@@ -33,7 +38,7 @@ import numpy as np
 class SoftOpt:
     def __init__(self, n_params, g_delta, lr=0.02, betas=(0.9, 0.999), eps=1e-8,
                  newton_lo=-0.5, newton_hi=0.5, eta_fallback=0.3,
-                 h_fd=1e-4, seed=None, slope="model", _test_frozen_constant=1.0):
+                 h_fd=1e-4, seed=None, slope="model", exact_d2="auto", _test_frozen_constant=1.0):
         if slope not in ("model", "measured"):
             raise ValueError(f'slope must be "model" or "measured", got {slope!r}')
         self.slope = slope
@@ -45,6 +50,11 @@ class SoftOpt:
         self.newton_hi = newton_hi
         self.eta_fallback = eta_fallback
         self.h_fd = h_fd
+        if exact_d2 not in ("auto", True, False):
+            raise ValueError('exact_d2 must be "auto", True or False')
+        self._d1_d2 = getattr(g_delta, "d1_d2", None) if exact_d2 else None
+        if exact_d2 is True and self._d1_d2 is None:
+            raise ValueError("exact_d2=True needs a g_delta with a d1_d2 attribute (e.g. from soft_compile)")
         self.m = None
         self.v = None
         self.t = 0
@@ -113,13 +123,17 @@ class SoftOpt:
         if self._ablation_rng is None:
             self._ablation_rng = np.random.default_rng(
                 self.rng.integers(0, 2**63 - 1))
+        if self._d1_d2 is not None:          # exact: nested soft numbers, one pass
+            D1_model, D2_real = self._d1_d2(theta_after_adam, delta)
+        else:                                # finite difference of the exact g_delta
+            D1_model = None
+            gp = self.g_delta(theta_after_adam + self.h_fd * delta, delta)
+            gm = self.g_delta(theta_after_adam - self.h_fd * delta, delta)
+            D2_real = (gp - gm) / (2 * self.h_fd)
         if self.slope == "measured":
             D1 = float(measured_slope)       # from the real system
         else:
-            D1 = self.g_delta(theta_after_adam, delta)
-        gp = self.g_delta(theta_after_adam + self.h_fd * delta, delta)
-        gm = self.g_delta(theta_after_adam - self.h_fd * delta, delta)
-        D2_real = (gp - gm) / (2 * self.h_fd)
+            D1 = D1_model if D1_model is not None else self.g_delta(theta_after_adam, delta)
 
         if _test_magnitude_source in (None, 'real'):
             D2_used = D2_real
@@ -129,9 +143,12 @@ class SoftOpt:
             theta_f = _test_foreign_sampler(self._ablation_rng)
             delta_f = (self._ablation_rng.choice([-1.0, 1.0], size=n)
                        if _test_magnitude_source == 'foreign_point_and_dir' else delta)
-            gp_f = self.g_delta(theta_f + self.h_fd * delta_f, delta_f)
-            gm_f = self.g_delta(theta_f - self.h_fd * delta_f, delta_f)
-            D2_used = abs((gp_f - gm_f) / (2 * self.h_fd))
+            if self._d1_d2 is not None:
+                D2_used = abs(self._d1_d2(theta_f, delta_f)[1])
+            else:
+                gp_f = self.g_delta(theta_f + self.h_fd * delta_f, delta_f)
+                gm_f = self.g_delta(theta_f - self.h_fd * delta_f, delta_f)
+                D2_used = abs((gp_f - gm_f) / (2 * self.h_fd))
         else:
             raise ValueError(_test_magnitude_source)
 

{softopt-0.6.2 → softopt-0.6.4/softopt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: softopt
-Version: 0.6.2
+Version: 0.6.4
 Summary: A standalone optimizer for problems with a known computation graph, built on Klein–Maimon soft-number calculus
 Author: Ido Angel
 License: MIT
@@ -120,8 +120,18 @@ Your model needs to be built from arithmetic and the elementary functions the so
 
 The one thing to avoid is converting a traced value back to a plain number mid-model — `float(x)`, or `np.array(params)` on the parameter list, both silently discard the derivative. `soft_compile`'s verification catches this and says so.
 
+**Parameter scale.** SoftOpt's correction moves each parameter by at most 0.5 per step, a natural size for angles and other parameters of order 1. If your parameters live on a very different scale (pixel offsets of 0.03, prices in the thousands), rescale them to roughly ±1, or set the bound to match: `SoftOpt(n, g_delta, lr=..., newton_lo=-b, newton_hi=b)`.
+
 If you'd rather write the derivative function yourself — because your model lives in a simulator SoftOpt can't trace, or because you want the speed of a hand-tuned implementation — pass any `g_delta(theta, delta)` that returns the exact directional derivative, and skip `soft_compile` entirely.
 
+### Exact curvature (new in 0.6.4)
+
+The Newton correction needs two numbers along the probe direction: the slope D1 and the curvature D2. Since 0.6.4 both come from **one pass of your model on nested soft numbers**, with no step size. Each parameter enters as `θ + δ·ε₁ + δ·ε₂`, where each soft axis obeys the book's `ε² = 0`; the mixed `ε₁ε₂` part of the result is D2 exactly (Lemma 6.1 applied twice). `soft_compile` sets this up for you, and `SoftOpt` uses it automatically.
+
+A hand-written `g_delta` can opt in the same way by carrying an attribute `g_delta.d1_d2 = lambda theta, delta: (D1, D2)`. Without it, D2 is a central finite difference of your exact `g_delta` (`h_fd`, the 0.6.3 behaviour, unchanged). `exact_d2=False` forces the finite difference.
+
+On the H4 benchmark (FakeFez, 10 seeds) the exact-curvature engine (`benchmarks/vqe/soft_su2_exact.py`, `h4_exact_d2.py`) gives the same result as the published one: 400 vs 409 mHa at step 100 (p=0.56), both 10/10 against Adam with 67% of the gap closed. `examples/soft_tensor_demo.py` shows that the same nested construction on tensors reproduces SoftOptTorch's nested `torch.func.jvp` to rounding (4e-16).
+
 ## Where the slope comes from: `slope="model"` or `slope="measured"`
 
 Every correction is a Newton step, `-slope / curvature`, taken along one direction. The curvature always comes from your model. The slope has two possible sources:
@@ -204,6 +214,16 @@ All results below use IBM's `FakeFez` noise model via Qiskit + Aer, or realistic
 
 Both run SoftOpt with its default settings on IBM's `FakeFez` noise model: `benchmarks/vqe/h4_real_molecule.py`, `benchmarks/vqe/h2_vs_cobyla.py`.
 
+**Quantum machine learning**
+
+| Test | Baseline | Result | Win rate |
+|---|---|---|---|
+| Variational quantum classifier (Iris, 4 qubits, 24 parameters), same budget of 300 readings, 20 seeds | Adam | 25% lower training loss; test accuracy on the device 70.0% vs 66.3% | 20/20 (loss), 15/20 + 3 ties (accuracy) |
+| Variational quantum classifier (breast cancer, 8 qubits, 48 parameters), same budget, 10 seeds | Adam | 6% lower training loss; test accuracy on the device 90.0% vs 88.3% | 10/10 (loss), 7/10 + 2 ties (accuracy) |
+| Same two classifiers | COBYLA | lower training loss (Iris 16/20, cancer 10/10); test accuracy tied | 16/20, 10/10 (loss) |
+
+`benchmarks/qml/vqc.py --dataset iris|cancer`
+
 **Quantum control**
 
 | Domain | Improvement | Win rate |

{softopt-0.6.2 → softopt-0.6.4}/softopt.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ softopt.egg-info/top_level.txt
 tests/test_basic.py
 tests/test_causal.py
 tests/test_compile.py
+tests/test_exact_d2.py
 tests/test_measured_slope.py
 tests/test_soft_number.py
 tests/test_torch.py

softopt-0.6.4/tests/test_exact_d2.py

@@ -0,0 +1,47 @@
+"""
+Tests for the exact-curvature path (0.6.4): nested soft numbers give D2 with no step size, and a
+hand-written g_delta without d1_d2 keeps the 0.6.3 finite-difference behaviour bit for bit.
+"""
+import numpy as np
+from softopt import soft_compile, SoftOpt
+
+
+def _model(p):
+    x, y, z = p
+    return np.cos(x) * np.sin(y) + x * x * z + np.exp(0.3 * y) * z
+
+
+def test_soft_compile_attaches_exact_d1_d2():
+    g = soft_compile(_model, n_params=3)
+    assert hasattr(g, 'd1_d2')
+    rng = np.random.default_rng(0)
+    for _ in range(10):
+        t, d = rng.normal(0, 1, 3), rng.choice([-1.0, 1.0], 3)
+        D1, D2 = g.d1_d2(t, d)
+        assert np.isclose(D1, g(t, d), rtol=1e-12)
+        h = 1e-5
+        D2_fd = (g(t + h * d, d) - g(t - h * d, d)) / (2 * h)
+        assert np.isclose(D2, D2_fd, rtol=1e-6, atol=1e-8)
+
+
+def test_hand_written_g_delta_unchanged():
+    g = soft_compile(_model, n_params=3)
+    hand = lambda t, d: g(t, d)                      # no d1_d2 attribute -> finite difference
+    a = SoftOpt(3, hand, lr=0.02, seed=1)
+    b = SoftOpt(3, g, lr=0.02, seed=1, exact_d2=False)
+    ta = tb = np.array([0.3, -0.2, 0.5])
+    for _ in range(20):
+        gr = np.array([g(ta, e) for e in np.eye(3)])
+        ta, tb = a.step(ta, gr), b.step(tb, gr)
+    assert np.array_equal(ta, tb)
+
+
+def test_exact_and_fd_paths_agree():
+    g = soft_compile(_model, n_params=3)
+    a = SoftOpt(3, g, lr=0.02, seed=2)               # exact (auto)
+    b = SoftOpt(3, g, lr=0.02, seed=2, exact_d2=False)
+    ta = tb = np.array([0.3, -0.2, 0.5])
+    for _ in range(50):
+        ta = a.step(ta, np.array([g(ta, e) for e in np.eye(3)]))
+        tb = b.step(tb, np.array([g(tb, e) for e in np.eye(3)]))
+    assert np.allclose(ta, tb, atol=1e-6)