PyAntiGen 1.0.12__tar.gz → 1.0.13__tar.gz

{pyantigen-1.0.12 → pyantigen-1.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 1.0.12
+Version: 1.0.13
 Summary: Short one-line description of what PyAntiGen does
 Author: Open Source Contributor
 Author-email: Don <you@example.com>

{pyantigen-1.0.12 → pyantigen-1.0.13}/PyAntiGen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 1.0.12
+Version: 1.0.13
 Summary: Short one-line description of what PyAntiGen does
 Author: Open Source Contributor
 Author-email: Don <you@example.com>

pyantigen-1.0.13/PyAntiGen.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "1.0.13",
+  "distance": 0,
+  "node": "ga5c2cee6bb58358aeefd1f48b50c73b952bfa343",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-17"
+}

{pyantigen-1.0.12 → pyantigen-1.0.13}/framework/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.12'
-__version_tuple__ = version_tuple = (1, 0, 12)
+__version__ = version = '1.0.13'
+__version_tuple__ = version_tuple = (1, 0, 13)
 
-__commit_id__ = commit_id = 'g3450403b3'
+__commit_id__ = commit_id = 'ga5c2cee6b'

{pyantigen-1.0.12 → pyantigen-1.0.13}/framework/template/Example/Engine/Evaluator.py

@@ -208,7 +208,7 @@ def _init_worker(spec_blob):
           f"{time.time() - t0:.1f}s", flush=True)
 
 
-def _worker_nll(x):
+def _worker_nll(x, frozen_sigmas=None):
     """The joint NLL, evaluated with this worker's own compiled models."""
     from Engine.Optimize import evaluate_nll_fixed
 
@@ -221,17 +221,18 @@ def _worker_nll(x):
         events_dynamic=spec.events_dynamic, failure_value=FAILURE_VALUE,
         for_inference=getattr(spec, "for_inference", True),
         concentrated=getattr(spec, "concentrated", True),
+        frozen_sigmas=frozen_sigmas,
     )
 
 
-def _eval_task(x):
+def _eval_task(x, frozen_sigmas=None):
     """Evaluate one parameter vector. Never raises across the pool boundary."""
     if _WORKER["spec"] is None:
         return (FAILURE_VALUE, "worker-not-initialized", 0.0)
 
     t0 = time.time()
     try:
-        val = _worker_nll(x)
+        val = _worker_nll(x, frozen_sigmas=frozen_sigmas)
         _WORKER["n_evals"] += 1
         status = "ok" if np.isfinite(val) and val < FAILURE_VALUE else "sentinel"
         return (float(val), status, time.time() - t0)
@@ -522,7 +523,17 @@ def _profile_task(job):
         cache = {}
         cache_order = []
 
-        raw_objective = _make_nuisance_objective(_worker_nll, param_idx, n_params)
+        # Every profile point pins each floored block at its own sigma_used
+        # from the fit rather than letting it re-concentrate (see
+        # Engine.Optimize._freeze_floor) -- stamped onto the job by
+        # profile_batch's frozen_sigmas, not decided here, so the caller
+        # controls it per batch.
+        frozen = job.get("frozen_sigmas")
+
+        def _pinned_nll(x_full):
+            return _worker_nll(x_full, frozen_sigmas=frozen)
+
+        raw_objective = _make_nuisance_objective(_pinned_nll, param_idx, n_params)
 
         def nuisance_objective(x_nuisance, fixed_val):
             x_arr = np.asarray(x_nuisance, dtype=float)
@@ -877,32 +888,50 @@ class ParallelEvaluator:
 
     # -- evaluation --------------------------------------------------------
 
-    def evaluate_batch(self, xs, label=None):
-        """Evaluate every parameter vector in *xs*; return losses in input order."""
+    def evaluate_batch(self, xs, label=None, heartbeat_s=_HEARTBEAT_SECONDS,
+                       frozen_sigmas=None):
+        """Evaluate every parameter vector in *xs*; return losses in input order.
+
+        Uses submit/wait, not map -- see profile_batch's docstring for the
+        general reasoning. map() (the previous implementation here) returns
+        nothing until the WHOLE batch is done, so one slow straggler among
+        many fast points -- a slice-screen point far from the optimum landing
+        in a stiff numerical regime, say -- makes the entire batch silent for
+        as long as that one point takes, indistinguishable from a hang. A
+        heartbeat every heartbeat_s while nothing has landed answers that
+        directly: it says how many are done, how many are still in flight, and
+        an ETA once at least one has finished.
+
+        chunk_size no longer applies to this method: submitting one task per
+        vector is what makes the heartbeat and per-point completion visibility
+        possible at all, and no caller in this codebase sets chunk_size to
+        anything but the default anyway.
+
+        Still returns losses in INPUT order, not completion order -- unlike
+        profile_batch, whose callers key off fields in each job/result dict,
+        callers here (the slice screen especially) index into the return value
+        positionally.
+        """
         xs = [np.asarray(x, dtype=float) for x in xs]
-        if not xs:
+        n = len(xs)
+        if n == 0:
             return []
         if self._pool is None:
             self.start()
 
-        chunk = self.chunk_size
-        if chunk is None:
-            # Enough chunks to keep every worker fed, few enough to avoid
-            # per-task overhead dominating.
-            chunk = max(1, len(xs) // (self.n_workers * 4) or 1)
+        from concurrent.futures import wait, FIRST_COMPLETED
 
         t0 = time.time()
+        tag = f" [{label}]" if label else ""
         if self.verbose:
-            # map() returns nothing until the whole batch is done, so this line
-            # is the only warning the caller gets that the next stretch of
-            # silence is expected. Individual points are reported by
-            # profile_batch; this path deliberately trades that for chunking.
-            tag = f" [{label}]" if label else ""
-            print(f"[pool]{tag} {len(xs)} evaluation(s) submitted to "
-                  f"{self.n_workers} worker(s) in chunks of {chunk}; "
-                  f"no output until the batch completes.", flush=True)
+            print(f"[pool]{tag} {n} evaluation(s) submitted to "
+                  f"{self.n_workers} worker(s); progress every "
+                  f"{_fmt_dur(heartbeat_s)} until results start landing.",
+                  flush=True)
+
         try:
-            out = list(self._pool.map(_eval_task, xs, chunksize=chunk))
+            futures = {self._pool.submit(_eval_task, x, frozen_sigmas): i
+                      for i, x in enumerate(xs)}
         except RuntimeError as exc:
             if "bootstrapping phase" in str(exc):
                 # spawn re-imports the __main__ module in every worker. If the
@@ -922,15 +951,46 @@ class ParallelEvaluator:
                 ) from exc
             raise
 
-        losses = []
+        pending = set(futures)
+        out = [None] * n
+        work = 0.0
+        done = 0
         failures = []
-        for i, (val, status, secs) in enumerate(out):
-            losses.append(val)
-            self.total_worker_seconds += secs
-            if status != "ok":
-                failures.append((i, status))
 
-        self.n_evals += len(xs)
+        while pending:
+            finished, pending = wait(pending, timeout=heartbeat_s,
+                                     return_when=FIRST_COMPLETED)
+
+            if not finished:
+                if self.verbose:
+                    now = time.time()
+                    msg = (f"  [pool{tag}] {done}/{n} done, "
+                           f"{len(pending)} in flight, "
+                           f"{_fmt_dur(now - t0)} elapsed")
+                    if done:
+                        rate = done / max(now - t0, 1e-9)
+                        msg += f", ~{_fmt_dur((n - done) / rate)} remaining"
+                    else:
+                        msg += " (no point has finished yet, so no estimate)"
+                    print(msg, flush=True)
+                continue
+
+            for fut in finished:
+                i = futures[fut]
+                try:
+                    val, status, secs = fut.result()
+                except Exception as exc:
+                    val = FAILURE_VALUE
+                    status = f"error: {type(exc).__name__}: {exc}"
+                    secs = 0.0
+                out[i] = val
+                work += secs
+                self.total_worker_seconds += secs
+                if status != "ok":
+                    failures.append((i, status))
+                done += 1
+
+        self.n_evals += n
         self.n_failures += len(failures)
 
         if self.verbose:
@@ -939,22 +999,31 @@ class ParallelEvaluator:
             # wall time is the speedup actually realized. On the first batch it
             # includes worker startup, so it understates steady-state throughput
             # -- report both numbers rather than one flattering one.
-            work = sum(o[2] for o in out)
-            tag = f" [{label}]" if label else ""
-            print(f"[pool]{tag} {len(xs)} evals in {elapsed:.1f}s wall "
+            print(f"[pool]{tag} {n} evals in {elapsed:.1f}s wall "
                   f"({work:.1f}s of work, {work / elapsed:.1f}x, "
-                  f"{len(xs) / elapsed:.1f} eval/s)", flush=True)
+                  f"{n / elapsed:.1f} eval/s)", flush=True)
             if failures:
                 shown = "; ".join(f"#{i}: {s}" for i, s in failures[:3])
                 more = f" (+{len(failures) - 3} more)" if len(failures) > 3 else ""
                 print(f"[pool]{tag} {len(failures)} failed — {shown}{more}", flush=True)
 
-        return losses
+        return out
 
     def profile_batch(self, jobs, on_result=None, label=None,
-                      heartbeat_s=_HEARTBEAT_SECONDS, budget=None):
+                      heartbeat_s=_HEARTBEAT_SECONDS, budget=None,
+                      frozen_sigmas=None):
         """Run profile-likelihood points in parallel, within a wall budget.
 
+        ``frozen_sigmas``, stamped onto every job here rather than left to
+        each caller's job-building code, is a ``{(block_key_or_exp_id,
+        obs_label): sigma_used}`` lookup (see ``Engine.Optimize.
+        block_sigmas``) pinning each data-floored block found in it at its own
+        resolved sigma for the point's whole nuisance re-optimization, instead
+        of letting it re-concentrate as the nuisance vector moves -- see
+        ``Engine.Optimize._freeze_floor``. Every profile pass submitted
+        through one ``batch()`` closure gets it uniformly this way, with no
+        change needed at the individual job-building sites.
+
         Unlike ``evaluate_batch`` this uses submit/wait rather than map, because
         each job is minutes to hours long and results must be checkpointed *as
         they land* -- the whole point of checkpointing is that killing the run
@@ -994,7 +1063,10 @@ class ParallelEvaluator:
 
         t0 = time.time()
         results = []
-        backlog = list(jobs)
+        # Stamped once here, not per admitted job: unlike deadline/sec_per_eval
+        # this does not depend on the clock, so every job in the batch gets it
+        # up front.
+        backlog = [dict(j, frozen_sigmas=frozen_sigmas) for j in jobs]
         futures = {}
         pending = set()
         n_jobs = len(jobs)

{pyantigen-1.0.12 → pyantigen-1.0.13}/framework/template/Example/Engine/Fast_profile.py

@@ -281,13 +281,27 @@ def run_fast_profile(batch, nll_batch, res_x, nll_at_optimum, param_names,
                      n_rounds=DEFAULT_ROUNDS,
                      near_zero_frac=DEFAULT_NEAR_ZERO_FRAC,
                      span_decades=SPAN_DECADES,
-                     min_reach_decades=MIN_REACH_DECADES, verbose=True):
+                     min_reach_decades=MIN_REACH_DECADES, verbose=True,
+                     nll_at_optimum_profile=None):
     """Screen, then one capped profile point per crossed side, in rounds.
 
     *batch* has the profile_batch signature: ``batch(jobs, on_result, label)``.
     *nll_batch* evaluates a list of full parameter vectors, for the screen.
     Returns the report dict; :func:`print_fast_profile_report` renders it and
     :func:`fast_profile_summary` shrinks it for the results snapshot.
+
+    *nll_at_optimum* anchors the screen, which goes through *nll_batch* and so
+    is never sigma-frozen (see ``Engine.Optimize._freeze_floor``).
+    *nll_at_optimum_profile* anchors the profile points that come back through
+    *batch*, which the caller submits with each floored block's sigma pinned
+    at its own ``sigma_used`` from the fit (``frozen_sigmas=sigma_by_block``,
+    not the raw floor -- see ``Engine.Optimize._freeze_floor``). Reusing the
+    unfrozen anchor for a frozen point's dNLL would compare two different
+    objectives, and if freezing were done at the raw floor instead of the
+    block's own resolved sigma that mismatch could run to hundreds of nats
+    even a fraction of a Wald SE from the optimum, since most floored blocks
+    are not binding at a good fit. Defaults to *nll_at_optimum* when not
+    given, which is correct whenever the caller submits unfrozen points too.
     """
     from Engine.Optimize import _cold_simplex, _param_bounds
 
@@ -295,6 +309,8 @@ def run_fast_profile(batch, nll_batch, res_x, nll_at_optimum, param_names,
     n = len(param_names)
     scales = list(scales) if scales is not None else ["lin"] * n
     t_start = time.time()
+    if nll_at_optimum_profile is None:
+        nll_at_optimum_profile = nll_at_optimum
 
     # ── The screen, reused when this fit already has one ──────────────────
     screen = load_screen(ckpt_dir, param_names, res_x, threshold,
@@ -411,7 +427,7 @@ def run_fast_profile(batch, nll_batch, res_x, nll_at_optimum, param_names,
         nll = res.get("nll")
         ok = (res.get("status") == "ok" and nll is not None
               and np.isfinite(nll) and nll < FAILURE_VALUE)
-        d = float(nll) - float(nll_at_optimum) if ok else None
+        d = float(nll) - float(nll_at_optimum_profile) if ok else None
         prev = side["dnll"]
         side["status"] = res.get("status")
         side["rounds"].append({
@@ -525,7 +541,10 @@ def run_fast_profile(batch, nll_batch, res_x, nll_at_optimum, param_names,
 
     report = {
         "threshold": float(threshold),
-        "anchor": float(nll_at_optimum),
+        # The anchor every dNLL in this report was actually measured against
+        # -- the frozen one, since every round's points come back through
+        # batch(). Not the same number as the screen's own anchor above.
+        "anchor": float(nll_at_optimum_profile),
         "res_x": [float(v) for v in res_x],
         "param_names": list(param_names),
         "round_evals": int(round_evals),

{pyantigen-1.0.12 → pyantigen-1.0.13}/framework/template/Example/Engine/Identifiability.py

@@ -133,6 +133,17 @@ class UnidentifiableParameters(RuntimeError):
         )
 
 
+def _is_usable(p):
+    """Whether a slice point carries real information rather than a failure
+    sentinel. Shared by :func:`_verdict` (to find the true furthest usable
+    point) and :func:`run_slice_screen` (to decide whether a ladder's
+    outermost rung already settles a side) so the two never disagree about
+    what counts as a real crossing. ``nll < FAILURE_VALUE`` matters because
+    the sentinel is a large *finite* number, not inf or nan -- a failed
+    integration must not read as "crossed"."""
+    return np.isfinite(p["dnll"]) and p["nll"] < FAILURE_VALUE
+
+
 def _se_for(wald_se, param_idx):
     """The Wald SE for one parameter in optimizer space, or None.
 
@@ -313,14 +324,11 @@ def _verdict(points, bound, threshold, p_opt, sign, is_log,
     to be spent there. It is recorded rather than consumed: wiring it into the
     profile's opening grid is a separate change.
     """
-    def _usable(p):
-        return np.isfinite(p["dnll"]) and p["nll"] < FAILURE_VALUE
-
-    finite = [p for p in points if _usable(p)]
+    finite = [p for p in points if _is_usable(p)]
 
     inner = None
     for p in points:                       # points are ordered outward
-        if not _usable(p) or p["dnll"] > threshold:
+        if not _is_usable(p) or p["dnll"] > threshold:
             break
         inner = p["x_linear"]
 
@@ -389,25 +397,46 @@ def run_slice_screen(nll_batch, res_x, nll_at_optimum, param_names, bounds,
                      max_points=6, growth=2.0, range_factor=2.0,
                      span_decades=SPAN_DECADES,
                      min_reach_decades=MIN_REACH_DECADES, verbose=True):
-    """Evaluate every parameter's slice out across decades, as one batch.
-
-    A slice point has no dependency on any other, so all of them go out
-    together: this is the cheapest possible use of the pool, one evaluation per
-    point with no optimizer wrapped around it.
-
-    That shape has a second use. If evaluations far from the fitted values are
-    pathologically slow -- the region where the integrator struggles and
-    ``safe_simulate`` enters its retry ladder -- this finds out in minutes, and
-    says so plainly, instead of the run discovering it hours into a profile
-    batch where every stuck evaluation is buried inside a nuisance
-    minimization.
+    """Evaluate every parameter's slice out across decades, stopping each side
+    the moment it crosses.
+
+    The screen's job is to hand the profile a starting point, not to walk
+    every side all the way out. So the candidate ladder for each side --
+    :func:`screen_values`, unchanged -- is submitted one round at a time: round
+    *r* asks the pool for every side's *r*-th candidate, all still-active
+    sides together in one batch, which keeps this as parallel as the old
+    single-batch version was. A side is retired the instant one of its points
+    reads ``dnll > threshold`` and never contributes another evaluation --
+    :func:`_verdict` reads a side's state from whichever point is furthest out
+    among those actually evaluated, so nothing is lost by stopping there. A
+    side that never crosses keeps going, round after round, all the way to its
+    candidate list's last point -- the declared bound or ``span_decades`` out,
+    whichever is further, see :func:`screen_target` -- exactly as before,
+    because that is the one thing this screen has to be able to prove.
+
+    Why stopping matters now and did not always: once a block's sigma is
+    capped at a data-derived floor (``sigma_floor_from_data``), a point far
+    outside the fitted region can return a genuinely enormous NLL rather than
+    a merely large one -- the self-forgiving log(sigma) term that used to
+    compress a bad far-out fit is exactly what the floor removes -- and that
+    region is also where the integrator is slowest. A declared bound is a
+    user-supplied number with no guaranteed relationship to anything physical,
+    so nothing about it -- not "it is inside the box", not "it is only one
+    point" -- is safe to evaluate unconditionally. The only bound that is safe
+    is not asking for a point once its side has already answered the question.
+
+    The one thing round-by-round stopping gives up: a slice that crosses early
+    and then dips back below threshold at a point it never reaches would have
+    been read as "open" by a full evaluation, and reads "crossed" here
+    instead. That trades a slower profile on a rare, specific slice shape for
+    never paying an unbounded evaluation on the common one.
     """
     from Engine.Optimize import _param_bounds
 
     res_x = np.asarray(res_x, dtype=float)
     scales = list(scales) if scales is not None else ["lin"] * len(param_names)
 
-    plan, xs = [], []
+    plan = []
     for i, name in enumerate(param_names):
         is_log = scales[i] == "log10"
         lb, ub = _param_bounds(bounds, i)
@@ -418,21 +447,48 @@ def run_slice_screen(nll_batch, res_x, nll_at_optimum, param_names, bounds,
                                  range_factor=range_factor,
                                  span_decades=span_decades)
             plan.append({"index": i, "name": name, "side": side, "sign": sign,
-                         "is_log": is_log, "values": vals,
-                         "p_opt": float(res_x[i]),
-                         "bound": (lb if sign < 0 else ub)})
-            for v in vals:
-                x = res_x.copy()
-                x[i] = v
-                xs.append(x)
+                        "is_log": is_log, "values": vals, "points": [],
+                        "settled": False,
+                        "p_opt": float(res_x[i]),
+                        "bound": (lb if sign < 0 else ub)})
 
+    n_candidates = sum(len(e["values"]) for e in plan)
+    max_rounds = max((len(e["values"]) for e in plan), default=0)
     if verbose:
         print(f"\n[screen] slice screen: {len(param_names)} parameter(s) x 2 "
-              f"side(s) = {len(xs)} evaluation(s), submitted as one batch. "
-              f"No nuisance optimization: each point is an upper bound on the "
-              f"profile, which is all the screen needs.", flush=True)
-
-    values = list(nll_batch(xs, label="slice-screen")) if xs else []
+              f"side(s); up to {n_candidates} evaluation(s) across at most "
+              f"{max_rounds} round(s), one round per pool submission. A side "
+              f"stops the round it first crosses dNLL={threshold:g}; only "
+              f"sides still undecided pay for the next, further-out point. "
+              f"No nuisance optimization: each point is an upper bound on "
+              f"the profile, which is all the screen needs.", flush=True)
+
+    n_evaluations = 0
+    for r in range(max_rounds):
+        round_xs, round_owner = [], []
+        for entry in plan:
+            if entry["settled"] or r >= len(entry["values"]):
+                continue
+            v = entry["values"][r]
+            x = res_x.copy()
+            x[entry["index"]] = v
+            round_xs.append(x)
+            round_owner.append((entry, v))
+        if not round_xs:
+            break
+        if verbose:
+            print(f"[screen] round {r + 1}: {len(round_xs)} side(s) still "
+                  f"undecided.", flush=True)
+        n_evaluations += len(round_xs)
+        nlls = nll_batch(round_xs, label=f"slice-screen-r{r + 1}")
+        for (entry, v), nll in zip(round_owner, nlls):
+            nll = float(nll)
+            point = {"x": float(v),
+                    "x_linear": float(10.0 ** v if entry["is_log"] else v),
+                    "nll": nll, "dnll": float(nll - nll_at_optimum)}
+            entry["points"].append(point)
+            if _is_usable(point) and point["dnll"] > threshold:
+                entry["settled"] = True
 
     report = {"threshold": float(threshold),
               "anchor": float(nll_at_optimum),
@@ -440,25 +496,17 @@ def run_slice_screen(nll_batch, res_x, nll_at_optimum, param_names, bounds,
               "param_names": list(param_names),
               "span_decades": float(span_decades),
               "min_reach_decades": float(min_reach_decades),
-              "n_evaluations": len(xs),
+              "n_evaluations": n_evaluations,
+              "n_candidates": n_candidates,
               "parameters": {}}
 
-    pos = 0
     for entry in plan:
-        pts = []
-        for v in entry["values"]:
-            nll = float(values[pos])
-            pos += 1
-            pts.append({
-                "x": float(v),
-                "x_linear": float(10.0 ** v if entry["is_log"] else v),
-                "nll": nll,
-                "dnll": float(nll - nll_at_optimum),
-            })
-        side = _verdict(pts, entry["bound"], threshold, entry["p_opt"],
-                        entry["sign"], entry["is_log"],
+        side = _verdict(entry["points"], entry["bound"], threshold,
+                        entry["p_opt"], entry["sign"], entry["is_log"],
                         min_reach_decades=min_reach_decades)
         side["is_log"] = entry["is_log"]
+        side["stopped_early"] = bool(entry["settled"]
+                                     and len(entry["points"]) < len(entry["values"]))
         report["parameters"].setdefault(entry["name"], {})[entry["side"]] = side
 
     states = [s["state"] for sides in report["parameters"].values()

{pyantigen-1.0.12 → pyantigen-1.0.13}/framework/template/Example/Engine/Optimize.py

@@ -479,6 +479,42 @@ def _sigma_floor_for(obs_cfg, t_data, y_data, y_sim_ref=None):
     return (nf.sigma if nf is not None else None), nf
 
 
+def _freeze_floor(known_sigma, sigma_floor, frozen_value):
+    """Pin a floored block's sigma at *frozen_value* instead of re-concentrating.
+
+    Used during profile-point evaluation, wired from :func:`evaluate_nll_fixed`
+    down from :meth:`ParallelEvaluator.profile_batch`, so a floored block's
+    sigma sits still for the whole nuisance re-optimization instead of being
+    re-estimated at every point the profile visits -- that re-estimation is
+    the self-forgiveness the floor exists to stop when it pushes sigma_hat
+    *above* the floor, and is worth stopping just as much below it, where the
+    floor itself has nothing to say.
+
+    *frozen_value* is the block's own ``sigma_used`` at the fitted optimum
+    (``min(sigma_hat_opt, floor)``; see :func:`block_sigmas`), not the raw
+    floor constant. That matters: most floored blocks are *not* binding at a
+    good optimum (``sigma_hat_opt`` already sits below the floor, which is
+    exactly why the fit was allowed to reach it), and pinning those at the
+    floor anyway would inflate every such block's term for the whole profile,
+    not just far from the optimum where self-forgiveness is the actual risk --
+    flattening the profile's true local sensitivity and reporting a large,
+    spurious dNLL even a fraction of a Wald SE from the fitted value. Pinning
+    at the block's own resolved value instead reproduces the concentrated
+    likelihood exactly at the optimum (the anchor and the profile then agree
+    there by construction) and only departs from it exactly where the block's
+    fit genuinely degrades as the profiled parameter moves.
+
+    The main fit and every other diagnostic (Wald, slice, Sobol) pass
+    ``frozen_value=None`` and keep floored blocks profiled as before; only the
+    profile passes supply one. A block with no floor (``sigma_floor is
+    None``) is untouched either way, and a block with a true declared sigma
+    (``known_sigma`` already set) is never overridden.
+    """
+    if frozen_value is not None and known_sigma is None and sigma_floor is not None:
+        return float(frozen_value), None
+    return known_sigma, sigma_floor
+
+
 def _apply_n_eff_scale(weights, n_eff_scale):
     """Rescale a block's per-point weights to state an effective sample size.
 
@@ -729,6 +765,7 @@ def effective_k(param_names, blocks):
 def collect_loss_blocks(
     sim_results, groups, replicates, param_names, p_lin, p_dict,
     trace_collector=None, loss_components=None, seen=None,
+    frozen_sigmas=None,
 ):
     """Walk every loss element in *groups* and return ``{block: [sse, n]}``.
 
@@ -759,6 +796,9 @@ def collect_loss_blocks(
     every contributing block is added to it. Block count cannot measure data
     coverage once elements share a sigma_block, so coverage checks must count
     these instead.
+
+    ``frozen_sigmas`` is passed straight through to every element's sigma
+    resolution -- see :func:`_freeze_floor`.
     """
     blocks = {}
     for g_name, g_config in groups.items():
@@ -787,6 +827,7 @@ def collect_loss_blocks(
                     trace_collector=trace_collector, blocks=blocks,
                     block_key=elem.get("sigma_block") or key, seen=seen,
                     n_eff_scale=elem.get("n_eff_scale"),
+                    frozen_sigmas=frozen_sigmas,
                 )
             else:
                 sim = elem.get("simulation")
@@ -799,6 +840,7 @@ def collect_loss_blocks(
                     loss_config=lc, trace_collector=trace_collector,
                     blocks=blocks, block_key=elem.get("sigma_block") or key,
                     seen=seen, n_eff_scale=elem.get("n_eff_scale"),
+                    frozen_sigmas=frozen_sigmas,
                 )
 
             if loss_components is not None:
@@ -819,6 +861,7 @@ def loss_function_evaluated(
     block_key=None,
     seen=None,
     n_eff_scale=None,
+    frozen_sigmas=None,
 ):
     """
     Evaluate the loss for already simulated results.
@@ -830,6 +873,10 @@ def loss_function_evaluated(
     runs, so it does not depend on ``loss_type`` or on which sigma heuristic
     fired.  *block_key* lets the caller pin a stable identity for the element
     even when ``results_dict`` is keyed by a display label.
+
+    *frozen_sigmas*, when given, is a ``{(block_key_or_exp_id, obs_label):
+    sigma_used}`` lookup (see :func:`block_sigmas`) consulted for every
+    floored observable -- see :func:`_freeze_floor`.
     """
     loss_config = loss_config or {}
     observables_config = loss_config.get("observables", [])
@@ -920,11 +967,16 @@ def loss_function_evaluated(
             n_eff = obs_weights_v.sum()
             loss_type = obs_cfg.get("loss_type", "nll")
 
+            block_id = block_key if block_key is not None else exp_id
             known_sigma = _known_sigma_for(obs_cfg, obs_df, valid)
             sigma_floor, floor_obj = (
                 _sigma_floor_for(obs_cfg, t_data, y_data, y_sim_ref=y_pred)
                 if known_sigma is None else (None, None))
-            _record_block(blocks, block_key if block_key is not None else exp_id,
+            frozen_value = (frozen_sigmas.get((block_id, _short_obs_label(obs)))
+                           if frozen_sigmas else None)
+            known_sigma, sigma_floor = _freeze_floor(
+                known_sigma, sigma_floor, frozen_value)
+            _record_block(blocks, block_id,
                           obs, residuals, obs_weights_v,
                           known_sigma=known_sigma, sigma_floor=sigma_floor)
             if seen is not None:
@@ -1034,6 +1086,7 @@ def loss_function_composite(
     block_key=None,
     seen=None,
     n_eff_scale=None,
+    frozen_sigmas=None,
 ):
     """
     Evaluate aggregated composite loss across multiple simulated results.
@@ -1177,11 +1230,16 @@ def loss_function_composite(
         n_eff = obs_weights_v.sum()
         loss_type = obs_cfg.get("loss_type", "nll")
 
+        block_id = block_key if block_key is not None else exp_id
         known_sigma = _known_sigma_for(obs_cfg, obs_df, valid)
         sigma_floor, floor_obj = (
             _sigma_floor_for(obs_cfg, t_data, y_data, y_sim_ref=y_pred)
             if known_sigma is None else (None, None))
-        _record_block(blocks, block_key if block_key is not None else exp_id,
+        frozen_value = (frozen_sigmas.get((block_id, _short_obs_label(obs)))
+                       if frozen_sigmas else None)
+        known_sigma, sigma_floor = _freeze_floor(
+            known_sigma, sigma_floor, frozen_value)
+        _record_block(blocks, block_id,
                       obs, residuals, obs_weights_v,
                       known_sigma=known_sigma, sigma_floor=sigma_floor)
         if seen is not None:
@@ -1458,7 +1516,7 @@ def evaluate_nll_fixed(
     p, models, replicates, param_names, scales, groups, group_normalization,
     fixed_sigmas, model_text=None, paths=None, events_dynamic=False,
     failure_value=1e10, for_inference=True, concentrated=True,
-    include_constant=False,
+    include_constant=False, frozen_sigmas=None,
 ):
     """Joint NLL at *p* (optimizer space).
 
@@ -1474,6 +1532,12 @@ def evaluate_nll_fixed(
     ``concentrated=False`` reproduces the older frozen-sigma behaviour, where
     ``fixed_sigmas`` carries sigmas estimated once at the optimum. Retained for
     comparison against archived runs; it is not the inference path.
+
+    ``frozen_sigmas``, when given, pins every data-floored block found in it
+    at its own ``sigma_used`` from the fit (see :func:`block_sigmas`), instead
+    of letting it re-concentrate (up to its floor) at this particular point --
+    see :func:`_freeze_floor`. Only the profile passes supply this; every
+    other diagnostic leaves it None.
     """
     p_lin = _to_linear(p, scales)
     p_dict = dict(zip(param_names, p_lin.tolist()))
@@ -1487,6 +1551,7 @@ def evaluate_nll_fixed(
     if concentrated:
         blocks = collect_loss_blocks(
             sim_results, groups, replicates, param_names, p_lin, p_dict,
+            frozen_sigmas=frozen_sigmas,
         )
         if not blocks:
             return failure_value
@@ -2051,6 +2116,73 @@ def _resolve_profile_optimizer(method, optimizer_kwargs):
     return profile_method, profile_kwargs
 
 
+def _resolve_named(value, param_names, label):
+    """Normalize a per-parameter spec value (``x0`` or ``bounds``) to a list
+    aligned with ``param_names``.
+
+    Accepts a ``{name: value}`` dict or an explicit sequence already aligned
+    with ``param_names`` position-for-position -- the same duality
+    ``_resolve_scales`` already gives ``parameter_scale``, for the same
+    reason: ``param_names``, ``x0`` and ``bounds`` are three separately
+    authored per-parameter lists that today have no cross-check that they
+    actually correspond, so reordering or editing one without the matching
+    edit to the others is a silent misalignment, not an error. A dict closes
+    that off structurally.
+
+    Unlike ``parameter_scale``'s dict, where an unlisted name safely defaults
+    to "lin", there is no safe default for a missing x0 or bounds entry -- so
+    both an unknown name (a typo, or a name that's no longer in param_names)
+    and a missing one (an omission) raise, naming the parameter, rather than
+    silently doing something plausible-looking with the wrong one or falling
+    back to unbounded.
+    """
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        names = set(param_names)
+        unknown = sorted(set(value) - names)
+        missing = sorted(names - set(value))
+        if unknown or missing:
+            problems = []
+            if unknown:
+                problems.append(f"unknown name(s) {unknown}")
+            if missing:
+                problems.append(f"missing name(s) {missing}")
+            raise ValueError(
+                f"{label} dict does not match param_names: "
+                + "; ".join(problems)
+            )
+        return [value[name] for name in param_names]
+    values = list(value)
+    if len(values) != len(param_names):
+        raise ValueError(
+            f"{label} has {len(values)} entries but there are "
+            f"{len(param_names)} parameters"
+        )
+    return values
+
+
+def _resolve_bounds(bounds, param_names):
+    """``bounds`` as a ``{name: (lo, hi)}`` dict or an aligned sequence,
+    normalized to the list every downstream consumer (``_param_bounds``,
+    ``_multistart_points``, the Wald Hessian, the profile grid, ``EvalSpec``,
+    checkpoint fingerprinting) already expects. ``None`` means unbounded and
+    passes through unchanged -- see ``_resolve_named``.
+    """
+    return _resolve_named(bounds, param_names, "bounds")
+
+
+def _resolve_x0(x0, param_names):
+    """``x0`` as a ``{name: value}`` dict or an aligned sequence, normalized
+    the same way as ``_resolve_bounds``. Unlike bounds, x0 is required --
+    ``None`` is a spec error, not "no starting point".
+    """
+    resolved = _resolve_named(x0, param_names, "x0")
+    if resolved is None:
+        raise ValueError("x0 is required and was None")
+    return resolved
+
+
 def _auto_scale(value, bound, search_decades=None,
                 min_decades=_AUTO_MIN_DECADES):
     """Pick 'log10' or 'lin' for one parameter.
@@ -3773,6 +3905,20 @@ def run_parallel_profile(
     n_params = len(param_names)
     completed = checkpoint.load(param_names) if checkpoint is not None else \
         {n: {} for n in param_names}
+    # A loaded record's dnll was computed against whatever anchor was current
+    # in the launch that wrote it. If that differs from this launch's anchor
+    # -- the frozen-sigma anchor shipping is exactly such a change, see
+    # _run_parallel_profile_with_checkpoint -- every downstream threshold
+    # comparison below would silently compare against the wrong number.
+    # Recomputed here, once, from the anchor-independent nll every record
+    # already carries, so a resume is never wrong about the anchor a fresh
+    # point would use, and no checkpoint has to be discarded when the anchor
+    # definition changes.
+    for pts in completed.values():
+        for r in pts.values():
+            nll = r.get("nll")
+            r["dnll"] = (float(nll) - nll_at_optimum
+                        if nll is not None else float("nan"))
 
     def _lin(v, is_log):
         return 10.0 ** v if is_log else v
@@ -4748,7 +4894,7 @@ def _run_parallel_profile_with_checkpoint(
     n_grid, range_factor, se_span, n_refine, run_id, checkpoint_enabled=True,
     fixed_sigmas=None, warm_passes=1, max_extend=8, extend_growth=2.0,
     bracket_rtol=0.05, screen_span_decades=None, screen_min_reach_decades=None,
-    replicates=None,
+    replicates=None, sigma_by_block=None,
 ):
     """Wire the pool, the checkpoint store, the wall budget and the profile."""
     from Engine.Profile_checkpoint import (
@@ -4829,12 +4975,34 @@ def _run_parallel_profile_with_checkpoint(
     )
 
     def batch(jobs, on_result=None, label=None):
+        # sigma_by_block: every profile point is a nuisance re-optimization,
+        # and letting a floored block's sigma re-concentrate at each point is
+        # the same self-forgiveness the floor exists to stop. Pinned instead
+        # at the block's own sigma_used from the fit -- its floor only when
+        # the floor was actually binding there, its sharper sigma_hat
+        # otherwise -- for the whole profile. See _freeze_floor.
         return evaluator.profile_batch(jobs, on_result=on_result, label=label,
-                                       budget=budget)
+                                       budget=budget,
+                                       frozen_sigmas=sigma_by_block)
+
+    # Every profile point comes back frozen (batch, above), so dNLL has to be
+    # read against an anchor computed the same way -- reusing nll_at_optimum
+    # (unfrozen; correct for the screen just above) would compare a frozen
+    # point's NLL against an unfrozen anchor. Freezing each block at its own
+    # sigma_used from the fit (rather than always at the raw floor) means this
+    # reproduces the concentrated likelihood exactly at the optimum, so the
+    # two anchors should differ only by float noise -- a real gap here means
+    # sigma_by_block does not match opt_blocks, not that floors are binding.
+    nll_at_optimum_frozen = evaluator.evaluate_batch(
+        [res_x], label="profile-anchor-frozen", frozen_sigmas=sigma_by_block)[0]
+    drift = nll_at_optimum_frozen - nll_at_optimum
+    print(f"[profile] frozen anchor at the optimum: {nll_at_optimum_frozen:.6g} "
+          f"(unfrozen: {nll_at_optimum:.6g}, {drift:+.6g}) -- every profile "
+          f"dNLL below is measured from the frozen value.")
 
     try:
         traces, anchor, where, convergence = run_parallel_profile(
-            batch, res_x, nll_at_optimum, param_names,
+            batch, res_x, nll_at_optimum_frozen, param_names,
             bounds, scales, method=method, optimizer_kwargs=optimizer_kwargs,
             wald_se=wald_se, n_grid=n_grid, range_factor=range_factor,
             se_span=se_span, n_refine=n_refine, checkpoint=ckpt,
@@ -4859,6 +5027,7 @@ def _run_fast_profile_with_checkpoint(
     checkpoint_enabled=True, fixed_sigmas=None, replicates=None,
     round_evals=None, n_rounds=None, near_zero_frac=None,
     screen_span_decades=None, screen_min_reach_decades=None,
+    sigma_by_block=None,
 ):
     """Wire the pool, the checkpoint store and the wall budget to the fast pass.
 
@@ -4898,18 +5067,43 @@ def _run_fast_profile_with_checkpoint(
     print(f"[fast profile] {budget.describe()}")
 
     def batch(jobs, on_result=None, label=None):
+        # Same reasoning as the full profile's own batch() -- a fast-profile
+        # point is also a nuisance re-optimization, so each floored block's
+        # sigma is pinned at its own sigma_used from the fit (its floor only
+        # where that was actually binding) for the point rather than
+        # re-concentrated at it. See _freeze_floor.
         return evaluator.profile_batch(jobs, on_result=on_result, label=label,
-                                       budget=budget)
+                                       budget=budget,
+                                       frozen_sigmas=sigma_by_block)
 
     def nll_batch(xs, label=None):
+        # Plain evaluations for the screen this pass reuses -- no nuisance
+        # re-optimization happens here, so left unfrozen like every other
+        # slice-style evaluation.
         return evaluator.evaluate_batch(xs, label=label)
 
+    # See the full profile's own comment at the matching line: batch() above
+    # submits every point frozen at sigma_by_block, so its dNLL has to be
+    # read against an anchor computed the same way, not the unfrozen
+    # nll_at_optimum the screen (nll_batch) uses. Freezing at each block's own
+    # sigma_used (not the raw floor) means this should equal nll_at_optimum to
+    # float noise -- a real gap means sigma_by_block is stale, not that floors
+    # are binding.
+    nll_at_optimum_frozen = evaluator.evaluate_batch(
+        [res_x], label="profile-anchor-frozen", frozen_sigmas=sigma_by_block)[0]
+    drift = nll_at_optimum_frozen - nll_at_optimum
+    print(f"[fast profile] frozen anchor at the optimum: "
+          f"{nll_at_optimum_frozen:.6g} (unfrozen: {nll_at_optimum:.6g}, "
+          f"{drift:+.6g}) -- every profile-point dNLL below is measured "
+          f"from the frozen value.")
+
     try:
         report = run_fast_profile(
             batch, nll_batch, res_x, nll_at_optimum, param_names, bounds,
             scales, method=method, optimizer_kwargs=optimizer_kwargs,
             wald_se=wald_se, wald_cov=wald_cov, checkpoint=ckpt,
             ckpt_dir=ckpt.dir, threshold=_PROFILE_THRESHOLD,
+            nll_at_optimum_profile=nll_at_optimum_frozen,
             round_evals=(round_evals if round_evals is not None
                          else DEFAULT_ROUND_EVALS),
             n_rounds=n_rounds if n_rounds is not None else DEFAULT_ROUNDS,
@@ -5327,8 +5521,14 @@ def run_optimization_from_groups(
     # =========================================================================
     if optimization_spec is not None:
         param_names = optimization_spec.param_names
-        x0_lin = optimization_spec.x0
-        bounds_lin = optimization_spec.bounds
+        # x0 and bounds may each be authored as a {name: value} dict or a
+        # sequence already aligned with param_names -- resolved to the aligned
+        # list here, once, so every consumer below and in every module this
+        # spec's fields get threaded into (Engine.Evaluator's EvalSpec,
+        # checkpoint fingerprinting, the profile grid, ...) keeps working with
+        # plain positional values exactly as before. See _resolve_named.
+        x0_lin = _resolve_x0(optimization_spec.x0, param_names)
+        bounds_lin = _resolve_bounds(optimization_spec.bounds, param_names)
         method = optimization_spec.method
         optimizer_kwargs = optimization_spec.optimizer_kwargs or {}
         selected_group_names = set(optimization_spec.groups.keys())
@@ -6075,6 +6275,7 @@ def run_optimization_from_groups(
                                 screen_span_decades=screen_span_decades,
                                 screen_min_reach_decades=(
                                     screen_min_reach_decades),
+                                sigma_by_block=sigma_by_block,
                             )
                         )
                 elif profile_likelihood_analysis:
@@ -6120,6 +6321,7 @@ def run_optimization_from_groups(
                                 screen_min_reach_decades=(
                                     screen_min_reach_decades),
                                 replicates=active_replicates,
+                                sigma_by_block=sigma_by_block,
                             )
                         )
 

pyantigen-1.0.12/PyAntiGen.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "1.0.12",
-  "distance": 0,
-  "node": "g3450403b38a37a7b62ac7644e0d82e8592310347",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-09-16"
-}