agentevolve-optimizer 0.6.0__tar.gz → 0.6.1__tar.gz

{agentevolve_optimizer-0.6.0 → agentevolve_optimizer-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentevolve-optimizer
-Version: 0.6.0
+Version: 0.6.1
 Summary: A drop-in NSGA-II replacement whose authored machinery installs only when measurement says it beats the classical path
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/dyigitpolat/agent_evolve

{agentevolve_optimizer-0.6.0 → agentevolve_optimizer-0.6.1}/src/agent_evolve/__init__.py

@@ -31,7 +31,7 @@ from agent_evolve.proposers.random_proposer import RandomProposer
 #: The one place the version is written. `pyproject.toml` declares
 #: `dynamic = ["version"]` and reads this literal, so the distribution metadata
 #: and the importable attribute cannot disagree.
-__version__ = "0.6.0"
+__version__ = "0.6.1"
 
 #: The supported public surface.
 __all__ = [

{agentevolve_optimizer-0.6.0 → agentevolve_optimizer-0.6.1}/src/agent_evolve/api.py

@@ -418,6 +418,11 @@ def optimize(
     intensify_pin_range: tuple = _INTENSIFY_PIN_RANGE,
     intensify_burst: int = 0,
     elite_mix: float = 0.0,
+    actuation: str = "off",
+    walk: str = "off",
+    walk_fraction: float = 0.25,
+    joints: int = 0,
+    joint_share: float = 0.0,
 ) -> SearchResult:
     """Optimize *problem* within *budget* evaluations.
 
@@ -517,6 +522,10 @@ def optimize(
     if intensify not in ("off", "incumbent"):
         raise ValueError(
             f"intensify must be 'off' or 'incumbent', got {intensify!r}")
+    if joint_share > 0.0 and joints <= 0:
+        raise ValueError(
+            "joint_share spends the reply's candidates block, and joints=0 "
+            "never invites one: raise joints or drop joint_share")
     if effort is not None and not isinstance(effort, str):
         raise ValueError(
             f"effort must be a provider effort level as a string, got {effort!r}"
@@ -587,6 +596,10 @@ def optimize(
              _moved(intensify_pin_range, _INTENSIFY_PIN_RANGE)),
             ("intensify_burst", intensify_burst != 0),
             ("elite_mix", elite_mix != 0.0),
+            ("actuation", actuation != "off"),
+            ("walk", walk != "off"),
+            ("joints", joints != 0),
+            ("joint_share", joint_share != 0.0),
             ("effort", effort is not None),
             ("journal", journal is not None),
             ("authorship", authorship_config is not None
@@ -746,7 +759,8 @@ def optimize(
                         domain_context=domain_card(bound),
                         style=("committed"
                                if prior == "llm-weighted-committed"
-                               else "cautious"))
+                               else "cautious"),
+                        joints=int(joints))
 
             if authorship_config is None:
                 if complete is not None:
@@ -814,6 +828,10 @@ def optimize(
                     intensify_pin_range=intensify_pin_range,
                     intensify_burst=intensify_burst,
                     elite_mix=elite_mix,
+                    actuation=actuation,
+                    walk=walk,
+                    walk_fraction=walk_fraction,
+                    joint_share=joint_share,
                 ),
                 chooser=chooser_policy,
                 log=announce,

{agentevolve_optimizer-0.6.0 → agentevolve_optimizer-0.6.1}/src/agent_evolve/policies/genetic.py

@@ -35,6 +35,7 @@ __all__ = [
     "mutate",
     "one_mutation_neighbourhood",
     "local_probe_candidate",
+    "ball_candidate",
     "uniform_candidate",
     "coverage_counts",
     "coverage_candidate",
@@ -737,6 +738,49 @@ def local_probe_candidate(
     return write_locus(anchor, locus, nearest[rng.randrange(len(nearest))])
 
 
+def ball_candidate(
+    anchor: Mapping[str, Any],
+    candidate_model: Any,
+    *,
+    rng: random.Random,
+    radius: int,
+) -> dict[str, Any]:
+    """*anchor* with every ordered locus stepped within +/- *radius* levels.
+
+    The walk operator (REFINEMENT_ROUND.md X3), shaped by what the specialist
+    traces actually do: the winning optimizer contracts to a ~0.4-level ball
+    around its incumbent by its first model-driven batch and then takes
+    ~0.3-level improving steps -- while this loop's own evaluations landed
+    within 2 levels of its champion 0.9% of the time and its improvement
+    events were 5-level teleports. A ball sample steps each NUMERIC ordered
+    locus by a uniform draw in [-radius, +radius] of the anchor's ladder
+    index (clamped to the declared ends); an unordered locus resamples
+    uniformly with the mutation-default probability 1/n, since a categorical
+    axis has no "nearby". Radius 1 is the smallest walk; the caller anneals.
+    """
+
+    out = dict(anchor)
+    loci = loci_of(anchor)
+    n = max(1, len(loci))
+    for locus in loci:
+        domain = locus_domain(candidate_model, locus)
+        if not domain or len(domain) < 2:
+            continue
+        current = read_locus(out, locus)
+        numeric = all(isinstance(v, (int, float)) and not isinstance(v, bool)
+                      for v in domain)
+        if numeric and current in domain:
+            index = list(domain).index(current)
+            step = rng.randint(-max(1, radius), max(1, radius))
+            out = write_locus(
+                out, locus,
+                domain[max(0, min(len(domain) - 1, index + step))])
+        elif rng.random() < 1.0 / n:
+            choices = tuple(v for v in domain if v != current) or domain
+            out = write_locus(out, locus, choices[rng.randrange(len(choices))])
+    return out
+
+
 def uniform_candidate(
     template: Mapping[str, Any],
     candidate_model: Any,

{agentevolve_optimizer-0.6.0 → agentevolve_optimizer-0.6.1}/src/agent_evolve/policies/llm_init.py

@@ -34,7 +34,8 @@ import re
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, List, Optional, Sequence
 
-from agent_evolve.policies.genetic import Locus, loci_of, locus_domain, read_locus
+from agent_evolve.policies.genetic import (
+    Locus, loci_of, locus_domain, read_locus, write_locus)
 
 __all__ = ["InitTelemetry", "author_initial_population", "INIT_PROMPT",
            "SPLIT_INIT_PROMPT", "INIT_STYLES"]
@@ -182,6 +183,39 @@ def _rejection(member: Any, template: Config, candidate_model: Any) -> Optional[
     return None
 
 
+def _snap_member(member: Any, candidate_model: Any) -> Any:
+    """Numeric "about X" values snapped to their nearest declared rung.
+
+    The measured defect (REFINEMENT_ROUND.md, X2a): 11.5% of authored init
+    cells carried off-ladder numerics -- 1.61461 where the rungs are 1.50394
+    and 1.6623 -- and whole-member rejection discarded the member. The model
+    speaks continuous; the grid is quantized; snapping WITHIN the declared
+    span is a codec, not a repair: out-of-span values are left untouched and
+    still judged by :func:`_rejection`, and non-numeric domains never snap.
+    """
+
+    from agent_evolve.policies.weighted_prior import snap_to_rung
+
+    if not isinstance(member, dict):
+        return member
+    out = dict(member)
+    try:
+        loci = loci_of(out)
+    except Exception:
+        return member
+    changed = False
+    for locus in loci:
+        domain = locus_domain(candidate_model, locus)
+        if not domain:
+            continue
+        value = read_locus(out, locus)
+        snapped = snap_to_rung(value, domain)
+        if snapped != value and snapped in domain:
+            out = write_locus(out, locus, snapped)
+            changed = True
+    return out if changed else member
+
+
 def author_initial_population(
     complete: Callable[[str], str],
     *,
@@ -251,6 +285,7 @@ def author_initial_population(
             if subset:
                 setattr(tel, f"{subset}_proposed",
                         getattr(tel, f"{subset}_proposed") + 1)
+            member = _snap_member(member, candidate_model)
             reason = _rejection(member, template, candidate_model)
             if reason == "shape":
                 tel.rejected_shape += 1

{agentevolve_optimizer-0.6.0 → agentevolve_optimizer-0.6.1}/src/agent_evolve/policies/weighted_prior.py

@@ -53,6 +53,8 @@ __all__ = [
     "llm_weighted_prior_proposer",
     "floor_weights",
     "PRIOR_FLOOR",
+    "band_fill",
+    "snap_to_rung",
     "PROMPT",
     "COMMITTED_PROMPT",
     "PRIOR_STYLES",
@@ -102,6 +104,16 @@ class WeightedRestriction:
     weighted: Mapping[str, tuple[tuple[Any, ...], tuple[float, ...]]] = field(
         default_factory=dict
     )
+    #: X1, the joint-candidate channel (REFINEMENT_ROUND.md): weighted whole
+    #: or partial configurations the reply named DIRECTLY. The trace
+    #: forensics found live replies already smuggling 4-8 joint configs
+    #: through the marginals (17/24 tapes), which a product-of-marginals
+    #: draw reproduces with probability ~1e-17; this field is where they
+    #: survive instead. Entries are ({field: value, ...}, weight) pairs,
+    #: validated per value at admission; the loop's joint_share knob decides
+    #: whether any slot ever draws them, so a populated field with the knob
+    #: off changes nothing.
+    candidates: tuple = ()
     misses: list[str] = field(default_factory=list, compare=False, repr=False)
 
     def __post_init__(self) -> None:
@@ -263,6 +275,82 @@ def floor_weights(
     return kept_values, tuple((1.0 - alpha) * s + alpha / k for s in shares)
 
 
+
+def _numeric_domain(domain: "tuple[Any, ...]") -> bool:
+    return bool(domain) and all(
+        isinstance(v, (int, float)) and not isinstance(v, bool) for v in domain)
+
+
+def snap_to_rung(value: Any, domain: "tuple[Any, ...]") -> Any:
+    """*value* snapped to the nearest declared rung of a NUMERIC domain.
+
+    The trace forensics that motivated this (REFINEMENT_ROUND.md, X2a): 11.5%
+    of authored init cells and a share of prior values are "about X" numbers
+    -- 1.61461 on a ladder whose rungs are 1.50394 and 1.6623 -- which
+    whole-reply rejection then discards wholesale. The model speaks
+    continuous; the grid is quantized; snapping within the domain's span is a
+    codec, not a repair: no value outside [min, max] of the declared rungs is
+    ever admitted, and non-numeric domains are untouched (returns *value*
+    unchanged, so the caller's own validation still judges it).
+    """
+
+    if not _numeric_domain(domain):
+        return value
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return value
+    lo, hi = min(domain), max(domain)
+    if not (lo <= float(value) <= hi):
+        return value
+    return min(domain, key=lambda rung: abs(float(rung) - float(value)))
+
+
+def band_fill(
+    values: "tuple[Any, ...] | list",
+    weights: "tuple[float, ...] | list",
+    *,
+    domain: "tuple[Any, ...]",
+) -> "tuple[tuple[Any, ...], tuple[float, ...]]":
+    """Unnamed rungs INSIDE the reply's own band get interpolated weights.
+
+    The measured defect (trace forensics, 24 tapes): replies name a band by
+    listing a few of its rungs, and 68.2% of the declared rungs lying
+    STRICTLY INSIDE that band got weight zero -- permanently, since the floor
+    is off. The reply's own extremes define the band; the schema's enumeration
+    forced the holes. This closes the holes and nothing else: on a NUMERIC
+    ordered domain, every unnamed rung between two named ones takes the linear
+    interpolation (in ladder-index space) of its named neighbours' weights;
+    named entries keep their exact weights, including explicit zeros; rungs
+    outside the named band stay excluded, so the prior's outer exclusion claim
+    survives and the unwind test still has something to test. Non-numeric
+    domains come back unchanged.
+    """
+
+    if not _numeric_domain(domain) or len(values) < 2:
+        return tuple(values), tuple(float(w) for w in weights)
+    index_of = {v: i for i, v in enumerate(domain)}
+    named = sorted(
+        ((index_of[v], float(w)) for v, w in zip(values, weights)
+         if v in index_of),
+        key=lambda pair: pair[0])
+    if len(named) < 2:
+        return tuple(values), tuple(float(w) for w in weights)
+    table = dict(named)                      # a duplicated rung: last wins
+    lo, hi = named[0][0], named[-1][0]
+    anchors = sorted(table)
+    out_v: list = []
+    out_w: list = []
+    for i in range(lo, hi + 1):
+        if i in table:
+            out_v.append(domain[i]); out_w.append(table[i])
+            continue
+        left = max(a for a in anchors if a < i)
+        right = min(a for a in anchors if a > i)
+        t = (i - left) / (right - left)
+        out_v.append(domain[i])
+        out_w.append((1.0 - t) * table[left] + t * table[right])
+    return tuple(out_v), tuple(out_w)
+
+
 def statistical_weighted_prior(
     attr: Attribution,
     candidate_model: Any = None,
@@ -315,6 +403,10 @@ class WeightedPriorTelemetry:
     empty: int = 0
     restricted_loci: int = 0
     errors: int = 0
+    snapped_values: int = 0
+    band_filled_rungs: int = 0
+    joint_accepted: int = 0
+    joint_rejected: int = 0
     proposals: list = field(default_factory=list)
 
     def as_dict(self) -> dict[str, int]:
@@ -326,6 +418,10 @@ class WeightedPriorTelemetry:
             "empty": self.empty,
             "restricted_loci": self.restricted_loci,
             "errors": self.errors,
+            "snapped_values": self.snapped_values,
+            "band_filled_rungs": self.band_filled_rungs,
+            "joint_accepted": self.joint_accepted,
+            "joint_rejected": self.joint_rejected,
             "proposals": len(self.proposals),
         }
 
@@ -350,7 +446,19 @@ weight zero and is not sampled; a locus you omit stays free. You are not
 choosing a candidate and must not propose one. {closing}
 
 Reply with ONLY this JSON shape and no other text:
-{{"weights": {{"<param>": {{"values": [...], "weights": [...]}}}}, "free": ["<param>", ...]}}"""
+{{"weights": {{"<param>": {{"values": [...], "weights": [...]}}}}, "free": ["<param>", ...]{joints_shape}}}"""
+
+_JOINTS_CLAUSE = """
+
+Weights are per-parameter marginals and cannot express COMBINATIONS. If the
+evidence suggests specific joint configurations -- parameters that work
+together -- name up to {k} of them directly as candidates: each a complete or
+partial configuration with a non-negative weight (higher weight, more draws).
+Values must come from the declared domains; omitted parameters stay free."""
+
+_JOINTS_SHAPE = (
+    ', "candidates": [{{"config": {{"<param>": <value>, ...}}, '
+    '"weight": <w>}}, ...]')
 
 _CAUTIOUS_CLOSE = (
     "Over-restricting a\nfrontier-spreading parameter destroys diversity: "
@@ -387,6 +495,7 @@ def llm_weighted_prior_proposer(
     domain_context: str = "",
     style: str = "cautious",
     prior_floor: float | None = None,
+    joints: int = 0,
 ) -> Callable[[Attribution, Any], WeightedRestriction]:
     """A prior proposer that elicits a GRADED prior and repairs nothing.
 
@@ -423,6 +532,11 @@ def llm_weighted_prior_proposer(
             f"weighted prior style must be one of {PRIOR_STYLES}, got "
             f"{style!r}")
     template = COMMITTED_PROMPT if style == "committed" else PROMPT
+    if joints > 0:
+        template = template.replace(
+            "Reply with ONLY this JSON shape",
+            _JOINTS_CLAUSE.format(k=int(joints)).strip()
+            + "\n\nReply with ONLY this JSON shape")
     tel = telemetry if telemetry is not None else WeightedPriorTelemetry()
     goals = ", ".join(objective_lines(objectives))
     preamble = f"{domain_context.strip()}\n\n" if domain_context.strip() else ""
@@ -435,6 +549,7 @@ def llm_weighted_prior_proposer(
         prompt = preamble + template.format(
             n=attr.n_evaluated,
             goals=goals,
+            joints_shape=(_JOINTS_SHAPE if joints > 0 else ""),
             schema="\n".join(f"  {line}" for line in described)
             if described else
             "\n".join(f"  {k}: one of {list(v)}" for k, v in domains.items()),
@@ -482,6 +597,13 @@ def llm_weighted_prior_proposer(
                 tel.out_of_domain += 1
                 return WeightedRestriction({})
             domain = tuple(domains[name])
+            if any(v not in domain for v in values):
+                # X2a: continuous-to-grid codec, in-span only, numeric only.
+                snapped = [snap_to_rung(v, domain) for v in values]
+                tel.snapped_values += sum(
+                    1 for old, new in zip(values, snapped)
+                    if old != new and new in domain)
+                values = snapped
             if any(v not in domain for v in values):
                 tel.out_of_domain += 1
                 return WeightedRestriction({})
@@ -504,17 +626,58 @@ def llm_weighted_prior_proposer(
             # what the model wrote, and what is installed is what the loop
             # will sample from. Reading the reply and installing it are two
             # different acts and only the second one is insured.
+            # X2a: a snap can land two "about X" values on one rung; the
+            # rung keeps their combined intent.
+            merged: dict[Any, float] = {}
+            for v, w in zip(values, clean):
+                merged[v] = merged.get(v, 0.0) + w
+            values = list(merged)
+            clean = [merged[v] for v in values]
+            filled_v, filled_w = band_fill(values, clean, domain=domain)
+            tel.band_filled_rungs += max(0, len(filled_v) - len(values))
             weighted[name] = floor_weights(
-                values, clean, domain=domain, floor=prior_floor)
-
-        if not weighted:
+                filled_v, filled_w, domain=domain, floor=prior_floor)
+
+        joint_pool: list = []
+        if joints > 0:
+            for item in (raw.get("candidates") or [])[: int(joints)]:
+                if not isinstance(item, dict):
+                    continue
+                fragment = item.get("config")
+                weight = item.get("weight", 1.0)
+                if (not isinstance(fragment, dict) or not fragment
+                        or isinstance(weight, bool)
+                        or not isinstance(weight, (int, float))
+                        or not math.isfinite(float(weight))
+                        or float(weight) < 0.0):
+                    tel.joint_rejected += 1
+                    continue
+                clean_frag: dict = {}
+                ok = True
+                for fname, fvalue in fragment.items():
+                    if fname not in domains:
+                        ok = False
+                        break
+                    fdomain = tuple(domains[fname])
+                    snapped = snap_to_rung(fvalue, fdomain)
+                    if snapped not in fdomain:
+                        ok = False
+                        break
+                    clean_frag[fname] = snapped
+                if ok and clean_frag:
+                    joint_pool.append((clean_frag, float(weight)))
+                    tel.joint_accepted += 1
+                else:
+                    tel.joint_rejected += 1
+
+        if not weighted and not joint_pool:
             tel.empty += 1
             return WeightedRestriction({})
         tel.restricted_loci += len(weighted)
         tel.proposals.append(
             {k: (list(v[0]), list(v[1])) for k, v in weighted.items()}
         )
-        return WeightedRestriction(weighted)
+        return WeightedRestriction(weighted, candidates=tuple(joint_pool))
 
     propose.telemetry = tel                    # type: ignore[attr-defined]
     propose.mechanism = "weighted_prior"       # type: ignore[attr-defined]