File size: 5,061 Bytes
b99b9ee | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 | """Generate a one-sentence English summary of where prediction disagrees
with observation.
Responsibility: convert a :class:`ResidualSummary` plus the two trajectories
into a deterministic English string the agent can use as feedback. No LLM
involved; this is templated text driven by simple rules over the numerical
residuals.
The output is the only place in the env where structured numerical state is
translated into natural language for the agent. We invest in this carefully
because a 1.5B model reasons better over short English sentences than over
100-row residual tables.
"""
from __future__ import annotations
from collections.abc import Iterable
import numpy as np
from physix.verifier.metrics import ResidualSummary
def summarize_mismatch(
observed: dict[str, np.ndarray],
predicted: dict[str, np.ndarray],
state_variables: Iterable[str],
timestamps: np.ndarray,
summary: ResidualSummary,
) -> str:
"""Return a one-sentence English description of the residual.
The sentence is built by:
1. Picking the variable with the **highest** late-window residual mean.
2. Inspecting whether the residual grows late in the trajectory (drift),
early in the trajectory (initial-condition mismatch), oscillates
around zero (phase / amplitude error), or stays uniformly small
(good fit).
3. Producing one descriptor for the dominant pattern.
Returns ``""`` if no residuals could be computed.
"""
if summary.overall_r2 >= 0.93:
return "Predicted and observed trajectories agree closely."
target = _pick_dominant_variable(summary, state_variables)
if target is None:
return ""
obs = observed[target]
pred = predicted[target]
residual = pred - obs
pattern = _classify_pattern(residual, timestamps)
return _render_sentence(target, pattern, summary, timestamps)
def _pick_dominant_variable(
summary: ResidualSummary,
state_variables: Iterable[str],
) -> str | None:
"""Pick the variable with the largest late-window residual mean."""
candidates: list[tuple[str, float]] = []
for var in state_variables:
if var in summary.per_variable_late_residual_mean:
candidates.append((var, summary.per_variable_late_residual_mean[var]))
if not candidates:
return None
return max(candidates, key=lambda kv: kv[1])[0]
def _classify_pattern(residual: np.ndarray, timestamps: np.ndarray) -> str:
"""Classify the dominant pattern of the residual into one of:
- ``"diverges_late"``: residual magnitude grows monotonically.
- ``"early_offset"``: large residual near t=0 then shrinks.
- ``"phase_or_amplitude"``: residual oscillates around zero with non-trivial amplitude.
- ``"uniform_small"``: residual is small everywhere.
"""
n = len(residual)
if n == 0:
return "uniform_small"
early_window = residual[: max(1, n // 4)]
late_window = residual[3 * n // 4 :]
abs_residual = np.abs(residual)
early_mag = float(np.mean(np.abs(early_window)))
late_mag = float(np.mean(np.abs(late_window)))
overall_mag = float(np.mean(abs_residual)) or 1e-9
# Sign-flip count: rough proxy for oscillation around zero.
sign_flips = int(np.sum(np.diff(np.sign(residual)) != 0))
if late_mag > 2.0 * early_mag and late_mag > 0.05 * float(np.ptp(residual) + 1e-9):
return "diverges_late"
if early_mag > 2.0 * late_mag:
return "early_offset"
if sign_flips > n // 5 and overall_mag > 0.05 * float(np.ptp(residual) + 1e-9):
return "phase_or_amplitude"
return "uniform_small"
def _render_sentence(
variable: str,
pattern: str,
summary: ResidualSummary,
timestamps: np.ndarray,
) -> str:
"""Render the chosen pattern into a single English sentence."""
t_max = summary.per_variable_t_of_max_residual.get(variable, 0.0)
max_abs = summary.per_variable_max_abs_residual.get(variable, 0.0)
if pattern == "diverges_late":
return (
f"Predicted {variable!s} diverges from observed past t={t_max:.1f}s "
f"(peak residual {max_abs:.2f}); the late-time behaviour is "
"structurally wrong (consider a missing damping, drag, or "
"saturation term)."
)
if pattern == "early_offset":
return (
f"Predicted {variable!s} is offset near t=0 (peak residual "
f"{max_abs:.2f} at t={t_max:.1f}s); the dynamics align later, "
"suggesting an initial-condition or constant-term mismatch."
)
if pattern == "phase_or_amplitude":
return (
f"Predicted {variable!s} oscillates around the observed but is "
f"out of phase or amplitude (peak residual {max_abs:.2f}); "
"consider tuning the natural frequency or adding light damping."
)
return (
f"Predicted {variable!s} matches observed broadly but residual is "
f"non-trivial (peak {max_abs:.2f} at t={t_max:.1f}s); fine-tune the "
"parameters."
)
|