PyAntiGen 2.1.3__tar.gz → 2.1.4__tar.gz

{pyantigen-2.1.3 → pyantigen-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 2.1.3
+Version: 2.1.4
 Summary: Declarative generation, simulation and identifiability analysis of compartmental Antimony/SBML models
 Author-email: Don Elbert <elbert5770@gmail.com>
 License-Expression: MIT

{pyantigen-2.1.3 → pyantigen-2.1.4}/PyAntiGen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAntiGen
-Version: 2.1.3
+Version: 2.1.4
 Summary: Declarative generation, simulation and identifiability analysis of compartmental Antimony/SBML models
 Author-email: Don Elbert <elbert5770@gmail.com>
 License-Expression: MIT

{pyantigen-2.1.3 → pyantigen-2.1.4}/PyAntiGen.egg-info/scm_file_list.json

@@ -103,6 +103,7 @@
     "tests/README.md",
     "tests/__init__.py",
     "tests/conftest.py",
+    "tests/engine/test_amici_flux_outputs.py",
     "tests/engine/test_amici_jumps.py",
     "tests/engine/test_amici_sensitivity.py",
     "tests/engine/test_analytic_gradient.py",

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

@@ -0,0 +1,8 @@
+{
+  "tag": "2.1.4",
+  "distance": 0,
+  "node": "g2e65abb870fe7cb1136e01bcd8c30b6d0f712dd6",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-14"
+}

{pyantigen-2.1.3 → pyantigen-2.1.4}/docs/ANALYTIC_GRADIENT.md

@@ -123,6 +123,9 @@ dynamics read them.
 * Columns that are not species, parameters or compartments (reaction rates) are not available to the
   loss; the gradient is then zero for anything that depends only on them.
 * The profile-likelihood stage keeps its own optimizers.
+  The gradient can differentiate what a profile point minimizes: `provider.freeze_sigmas(block_sigmas)` pins the floored blocks'
+  sigmas as `evaluate_nll_fixed(frozen_sigmas=...)` does (without it the gradient is off by 10 to 30% away from the fit);
+  `freeze_sigmas(None)` releases them. Nothing calls it yet.
 * Cost: the gradient costs one AMICI forward-sensitivity run, which grows with the number of
   parameters it differentiates. On SILK, 8 parameters: about 1.2 s a gradient against 9 objective
   evaluations (about 1.4 s) for forward differences; with all 48 parameters AMICI needs about 40 s a

{pyantigen-2.1.3 → pyantigen-2.1.4}/pyantigen/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.1.3'
-__version_tuple__ = version_tuple = (2, 1, 3)
+__version__ = version = '2.1.4'
+__version_tuple__ = version_tuple = (2, 1, 4)
 
-__commit_id__ = commit_id = 'g45ef1dd29'
+__commit_id__ = commit_id = 'g2e65abb87'

{pyantigen-2.1.3 → pyantigen-2.1.4}/pyantigen/engine/Analytic_gradient.py

@@ -91,6 +91,8 @@ class LossGradient:
         self.param_names = list(param_names)
         self.rel_step = float(rel_step)
         self.explicit = self._explicit_parameters()
+        # {(block, observable): sigma}: the floored blocks' sigmas a profile point holds still (see freeze_sigmas)
+        self.frozen_sigmas = None
 
     # -- which parameters the loss reads by name ------------------------------------
     def _explicit_parameters(self):
@@ -123,7 +125,8 @@ class LossGradient:
         from pyantigen.engine.Optimize import collect_loss_blocks, concentrated_nll
         p_dict = dict(zip(self.param_names, np.asarray(p_lin, dtype=float).tolist()))
         blocks = collect_loss_blocks(items, self.groups, self.replicates, self.param_names,
-                                     np.asarray(p_lin, dtype=float), p_dict)
+                                     np.asarray(p_lin, dtype=float), p_dict,
+                                     frozen_sigmas=self.frozen_sigmas)
         if not blocks:
             raise AnalyticGradientError("the loss has no data to score")
         v = concentrated_nll(blocks)
@@ -581,6 +584,16 @@ class AmiciGradient:
             points += [p for p in (lo, hi) if np.all(np.isfinite(p)) and not np.array_equal(p, x0)]
         return points
 
+    def freeze_sigmas(self, sigmas):
+        """Differentiate the loss a profile point minimizes: floored blocks keep the sigma they had at the fit.
+
+        *sigmas* is what ``Optimize.block_sigmas`` returns for the fit (``{(block, observable): sigma_used}``),
+        the same dictionary the profile passes to ``evaluate_nll_fixed(frozen_sigmas=...)``. A frozen block is
+        scored with that sigma instead of ``min(sigma_hat, floor)`` at the current point, which changes its
+        derivative (the sigma no longer moves with the parameters). ``None`` releases them.
+        """
+        self.loss.frozen_sigmas = dict(sigmas) if sigmas else None
+
     def linear_gradient(self, p_lin):
         """``(nll, d nll / d p_lin)`` evaluated on AMICI's own simulation."""
         items, dirs = {}, {}

{pyantigen-2.1.3 → pyantigen-2.1.4}/pyantigen/generate/scaled_time.py

@@ -23,7 +23,8 @@ What this module does to the model
   from per-segment constants ``sched_a0/a1`` and ``sched_c0_<m>/c1_<m>`` (the
   anchors and coefficients of the segment's two end points). The solver sees
   ``D`` as a function of the parameters.
-* Every reaction rate and every rate rule is multiplied by ``sched_Delta``.
+* Every reaction rate and every rate rule is multiplied by ``sched_Delta``; a formula that reads a reaction id
+  (a rule that sums fluxes) reads ``id/sched_Delta``, the flux of the unscaled model.
 * A measured curve ``c`` (an assignment rule in the model) becomes
   ``sched_ci_c + sched_cs_c*sched_clock``: on one segment it is a straight line.
 * Each parameter the schedule assigns (``Q_Leak``, ...) becomes a state with rate
@@ -133,6 +134,32 @@ def _with_clock(node):
     return _parse(_TIME_TOKEN.sub(CLOCK, libsbml.formulaToL3String(node)))
 
 
+_TOKEN = re.compile(r"(?<![A-Za-z0-9_.])[A-Za-z_][A-Za-z0-9_]*")
+
+
+def _reads_any(node, names):
+    if node.isName() and node.getName() in names:
+        return True
+    return any(_reads_any(node.getChild(i), names) for i in range(node.getNumChildren()))
+
+
+def _with_true_fluxes(node, reaction_ids):
+    """*node*'s mathematics with each reaction id read as the flux of the original time, as a new tree; None if it reads none.
+
+    A reaction id in a formula means the reaction's rate. Step 3 of :func:`scale_model` multiplies every rate law by
+    ``sched_Delta``, so a rule that sums fluxes (``BBB_transport := BBBTransport_AB42 + ...``) would read
+    ``Delta`` times the flux, and an output or a rate rule built on it would be wrong by the length of the segment.
+    Reading ``(R/sched_Delta)`` instead gives the rule the flux it has in the unscaled model, and the solver
+    differentiates the quotient, ``dDelta/dp`` included. Done on the formula text, for the reason given in
+    :func:`_with_clock`.
+    """
+    if not _reads_any(node, reaction_ids):
+        return None
+    text = _TOKEN.sub(lambda m: f"({m.group(0)}/{DELTA})" if m.group(0) in reaction_ids else m.group(0),
+                      libsbml.formulaToL3String(node))
+    return _parse(text)
+
+
 def _expand_initial(model, text, depth=0):
     """*text* with every parameter that has an initial assignment replaced by that assignment.
 
@@ -221,6 +248,25 @@ def scale_model(sbml, schedule):
         _add_parameter(model, f"{PREFIX}cs_{c}")
         rule.setMath(_parse(f"{PREFIX}ci_{c} + {PREFIX}cs_{c}*{CLOCK}"))
 
+    # 3a. a formula that reads a reaction id reads that reaction's rate: keep it the unscaled one
+    reaction_ids = {model.getReaction(i).getId() for i in range(model.getNumReactions())}
+    if reaction_ids:
+        for i in range(model.getNumRules()):
+            rule = model.getRule(i)
+            new = _with_true_fluxes(rule.getMath(), reaction_ids)
+            if new is not None:
+                rule.setMath(new)
+        for i in range(model.getNumReactions()):
+            kl = model.getReaction(i).getKineticLaw()
+            new = _with_true_fluxes(kl.getMath(), reaction_ids) if kl is not None and kl.isSetMath() else None
+            if new is not None:
+                kl.setMath(new)
+        for i in range(model.getNumInitialAssignments()):
+            assignment = model.getInitialAssignment(i)
+            new = _with_true_fluxes(assignment.getMath(), reaction_ids)
+            if new is not None:
+                assignment.setMath(new)
+
     # 3. rates times Delta (before the new rules, which must not be scaled)
     delta = lambda: _name_node(DELTA)  # noqa: E731
     for i in range(model.getNumReactions()):

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

@@ -1,8 +0,0 @@
-{
-  "tag": "2.1.3",
-  "distance": 0,
-  "node": "g45ef1dd293ac66f01a48a35895aa0b83ec9a6b96",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-13"
-}