Files
threshing-atlas/core/atlas/model.py
T
ekcSchianoandClaude Opus 5.5 c0355616b6 Route model learns from bot runs; Thompson sampling in the advisor (work in progress)
- planner/policy.yaml: which sources the route model learns from (spreadsheet,
  reported, bot) and the low-bias sample
- bot runs: deaths coded by stage, Malek intent for runs with a target
- model: survival of the first dragon is not counted when nothing after it is
  known; the meadow dragon falls back to what the bot saw
- solver.js: advisor(..., {sampling: "thompson", seed, draws}) follows one
  posterior draw per attempt and reports each pick's propensity

Not shipped yet: mixing sources lowers the fitted shrinkage for the shadow roll
(alpha 500 -> 50 in the low-bias sample), see the conversation of 2026-11-09.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UCzTd31GphpMXDhQqWrCMQ
2026-11-10 02:29:09 +00:00

408 lines
17 KiB
Python

"""From coded runs to the route model's numbers: what each run says about each step of the game (prepare_run),
how often each roll came out in each context (count_tables), how strongly to shrink toward shorter contexts
(fit_alpha), the probability source the solver uses (Params), and which options have enough data (support_from).
The game itself (steps, options, chance contexts) is core/spec/game.yaml.
The random numbers (xorshift32, Marsaglia-Tsang gamma) are the same as the route model has always used, so the
posterior draws are reproducible from the seed.
"""
import math
import numpy as np
from . import spec
G = spec.game()
DECISIONS = {k: v["options"] for k, v in G["decisions"].items()}
CHANCE = G["chance"]
COLOURS = G["colours"]
FROM_FORM = G["from_form"]
HELP = set(FROM_FORM["helped"])
IGNORE = set(FROM_FORM["ignored"])
FIGHT_OF = FROM_FORM["fight"]
DAGGER_OF = FROM_FORM["dagger"]
RARE_GOALS = FROM_FORM["rare_goals"]
NO_DAGGER = "(no dagger choice)"
ALONE = "(alone)"
ALPHA = 20
ALPHA_GRID = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 20000, 100000]
ENC_CATS = G["encounter_outcomes"]
def enc_colour(ctx):
return "Green" if ctx == "tree-Greens" else ctx.split("-")[1]
def dagger_after(fight, dagger):
"""The fight moves in a history: a run that charged straight in never faces the dagger."""
return None if fight is None else (dagger or None) if fight == "Pause to assess" else NO_DAGGER
# ---------------------------------------------------------------- 1. coded run -> what it says about each step
def genuine_attempt(r, ctx):
"""Whether a run's bonding attempt counts for this encounter, given the rider's stated goal and Malek intent."""
c = enc_colour(ctx)
g = r.get("goal") or ""
matches = g == c or g.startswith("Any") or (g == "Blue or Black" and c in ("Blue", "Black")) or \
(g == "Red (tree)" and ctx == "tree-Red")
if matches:
return True
if r.get("malek_intent") == "No":
return True
if r.get("malek_intent") == "Yes":
return False
specific_other = (g in COLOURS and g != c) or g == "Blue or Black" or g == "Red (tree)"
return not specific_other
def prepare_run(r):
"""One coded run (atlas.coding) as the steps of the game it reveals."""
v = {"company": r["company"] if r["company"] in DECISIONS["company"] else None,
"direction": r["direction"] if r["direction"] in DECISIONS["direction"] else None,
"fs": r["first_sighting"] if r["first_sighting"] in ("Red", "Brown", "Green", "Orange") else None}
lf = r.get("left_squadmates")
known = lf is not None and not (isinstance(lf, float) and lf != lf) and lf != ""
v["left"] = ALONE if v["company"] == "Alone" else (("Leave them" if lf is True or str(lf).lower() == "true" else "Stay together") if v["company"] and known else None)
v["react"] = r["sighting_action"] if r.get("sighting_action") in DECISIONS["react"] else None
v["diedSight"] = r["scream"] == "DIED at first sighting"
if v["diedSight"]:
return v
if r["scream"] not in ("Investigate & help", "Ignore the scream", "Investigate & leave"):
v["sightUnknown"] = True # no answer after the first dragon: whether the rider survived it is not known
return v
res = r["resolution"]
if r["scream"] == "Investigate & help":
v["help"] = True
v["fight"] = FIGHT_OF.get(r.get("combat_first"))
v["dagger"] = dagger_after(v["fight"], DAGGER_OF.get(r.get("combat_second")))
v["diedCombat"] = res == "DIED in combat"
v["cadet"] = res if res in HELP else None
if v["diedCombat"]:
return v
v["post"] = r["post_path"] if r.get("post_path") in DECISIONS["post"] else None
elif r["scream"] == "Ignore the scream":
v["cadet"] = res if res in IGNORE else None
v["post"] = "(no fork)"
elif r["scream"] == "Investigate & leave":
v["cadet"] = "Left them to it"
v["post"] = "(no fork)"
else:
return v
v["survivedCadets"] = True
v["diedHour"] = r["hour"] == "DIED before the hour"
if v["diedHour"]:
return v
v["hour"] = r["hour"] if r.get("hour") in DECISIONS["hour"] else None
b = r.get("branch")
if v["hour"] == "Tree" and b:
v["shadow"] = b == "Shadow (rare)"
if v["shadow"]:
v["shadowColour"] = "Black" if r.get("enc_Black") else "Blue"
v["encCtx"] = "shadow-" + v["shadowColour"]
elif b == "Descend quickly: Red":
v["descend"], v["red"], v["encCtx"] = "Quickly (Red)", "Jump onto the Red", "tree-Red"
elif b == "Descend quickly: let the Red pass":
v["descend"], v["red"], v["encCtx"] = "Quickly (Red)", "Let it pass (two Greens)", "tree-Greens"
elif b == "Descend slowly: two Greens":
v["descend"], v["encCtx"] = "Slowly (two Greens)", "tree-Greens"
elif v["hour"] == "Valley" and b:
if b == "Valley Red":
v["valley"], v["encCtx"] = "Face the Red", "valley-Red"
elif b == "Passed the Red: meadow":
v["valley"] = "Pass the Red (meadow)"
# the meadow dragon: Blue if one appeared, otherwise the one the rider ended the run with
ended = lambda c: r.get("enc_" + c) and r.get("enc_" + c) != "Changed my mind" # noqa: E731
v["meadow"] = "Blue" if (r.get("enc_Blue") or r.get("rare_reported") == "Blue (valley)") else \
"Orange" if ended("Orange") else "Brown" if ended("Brown") else \
"Orange" if r.get("enc_Orange") else "Brown" if r.get("enc_Brown") else \
"Blue" if r.get("saw_blue_meadow") is True else \
r["outcome_color"] if r.get("saw_blue_meadow") is False and r.get("outcome_color") in ("Orange", "Brown") else None
if v["meadow"]:
v["encCtx"] = "meadow-" + v["meadow"]
if v.get("encCtx"):
v["encOutcome"] = r["outcome_color"] if (r["outcome"] == "Bonded" and r.get("outcome_color")) else \
"burn" if r["outcome"] == "Incinerated" else None
if v["encOutcome"] and not genuine_attempt(r, v["encCtx"]):
v["encOutcome"] = None
return v
# what each chance event observed in a prepared run
OBSERVE = {
"fs": lambda v: v.get("fs"),
"dieSight": lambda v: ("die" if v.get("diedSight") else "live") if v.get("fs") and not v.get("sightUnknown") else None,
"dieCombat": lambda v: ("die" if v.get("diedCombat") else "live") if v.get("help") else None,
"dieHour": lambda v: ("die" if v.get("diedHour") else "live") if v.get("survivedCadets") else None,
"shadow": lambda v: None if "shadow" not in v else ("yes" if v["shadow"] else "no"),
"shadowColour": lambda v: v.get("shadowColour"),
"meadow": lambda v: v.get("meadow"),
}
assert set(OBSERVE) == set(CHANCE), "every chance event in game.yaml needs an OBSERVE rule"
def ctx_key(v, names):
return "|".join("?" if v.get(k) is None else str(v[k]) for k in names)
# ---------------------------------------------------------------- 2. counts
def count_tables(prepared):
"""Counts for every chance event at every back-off level, plus each encounter's outcomes."""
T = {}
for node, sp in CHANCE.items():
t = T[node] = {}
for v in prepared:
y = OBSERVE[node](v)
if not y:
continue
for L in range(len(sp["context"]) + 1):
names = sp["context"][:L]
if any(v.get(k) is None for k in names):
break
c = t.setdefault(f"{L}:{ctx_key(v, names)}", {})
c[y] = c.get(y, 0) + 1
enc = T["encounter"] = {}
for v in prepared:
if not v.get("encCtx"):
continue
c = enc.setdefault(v["encCtx"], {"outcomes": {}, "seen": {}})
if v.get("encOutcome"):
c["outcomes"][v["encOutcome"]] = c["outcomes"].get(v["encOutcome"], 0) + 1
# which colours can ever end a run in this context (from all runs, genuine or not)
for v in prepared:
if v.get("encCtx") and v.get("encOutcome") and v["encOutcome"] != "burn":
enc[v["encCtx"]]["seen"][v["encOutcome"]] = 1
return T
def support_from(prepared, min_n):
"""Options taken at least min_n times; options never recorded at all are not restricted."""
n = {}
def bump(k, o):
n.setdefault(k, {})
n[k][o] = n[k].get(o, 0) + 1
for v in prepared:
for k in ("company", "direction", "cadet", "hour", "descend", "valley"):
if v.get(k):
bump(k, v[k])
if v.get("left") and v["left"] != ALONE:
bump("leave", v["left"])
if v.get("fs") and v.get("react"):
bump("react:" + v["fs"], v["react"])
if v.get("post") and v["post"] != "(no fork)":
bump("post", v["post"])
# the cadet encounter's steps, including riders killed in the fight (they chose to help)
if v.get("help") or v.get("cadet"):
ignore = bool(v.get("cadet") and v["cadet"] in IGNORE)
bump("scream", "Keep walking" if ignore else "Investigate the scream")
if ignore:
bump("wounded", v["cadet"])
else:
bump("clearing", "Walk away" if v.get("cadet") == "Left them to it" else "Help your squadmate")
if v.get("cadet") in HELP:
bump("fate", v["cadet"])
if v.get("help") and v.get("fight"):
bump("fight", v["fight"])
if v.get("dagger") and v["dagger"] != NO_DAGGER:
bump("dagger", v["dagger"])
s = {"encounter": DECISIONS["encounter"]}
for k in ("company", "leave", "direction", "cadet", "scream", "clearing", "fight", "dagger", "fate", "wounded",
"post", "hour", "descend", "valley"):
s[k] = [o for o in DECISIONS[k] if n.get(k, {}).get(o, 0) >= min_n] or list(DECISIONS[k])
for fs in ("Red", "Brown", "Green", "Orange"):
k = "react:" + fs
s[k] = [o for o in DECISIONS["react"] if n.get(k, {}).get(o, 0) >= min_n] or list(DECISIONS["react"])
for k, d in G["decisions"].items():
if d.get("always_offered") and k != "encounter":
s[k] = list(d["options"])
return s, n
# ---------------------------------------------------------------- 3. empirical-Bayes concentration
def lgamma(x):
"""Log-gamma (Lanczos), the same approximation the route model has always used."""
c = [76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2,
-0.5395239384953e-5]
y = x
tmp = x + 5.5
tmp -= (x + 0.5) * math.log(tmp)
ser = 1.000000000190015
for v in c:
y += 1
ser += v / y
return -tmp + math.log(2.5066282746310005 * ser / x)
def fit_alpha(T, node):
"""The concentration that maximises the Dirichlet-multinomial likelihood of each back-off level given the one above."""
cats = CHANCE[node]["outcomes"]
t = T[node]
def pooled(key):
c = t.get(key, {})
a = [c.get(k, 0) + 0.5 for k in cats]
s = 0
for x in a:
s += x
return [x / s for x in a]
pairs = []
for key in t:
L = int(key.split(":")[0])
if L == 0:
continue
ctx = key[key.index(":") + 1:].split("|")
parent = f"{L - 1}:" + "|".join(ctx[:L - 1])
pairs.append(([t[key].get(k, 0) for k in cats], pooled(parent)))
if not pairs:
return {"alpha": ALPHA, "logLik": None}
best_a, best_ll, lls = ALPHA, -math.inf, {}
for a in ALPHA_GRID:
ll = 0
for c, p in pairs:
n = 0
for x in c:
n += x
ll += lgamma(a) - lgamma(n + a)
for i in range(len(cats)):
ll += lgamma(c[i] + a * p[i]) - lgamma(a * p[i])
lls[a] = ll
if ll > best_ll:
best_ll, best_a = ll, a
return {"alpha": best_a, "logLik": lls}
# ---------------------------------------------------------------- 4. random numbers (reproducible from the seed)
class Rng:
"""xorshift32, as in the original route model (JavaScript semantics)."""
def __init__(self, seed):
self.s = (seed & 0xFFFFFFFF) or 1
def __call__(self):
s = self.s
s = (s ^ (s << 13)) & 0xFFFFFFFF
s ^= s >> 17
s = (s ^ (s << 5)) & 0xFFFFFFFF
self.s = s
return s / 4294967296
def gamma(shape, rand):
if shape < 1:
g = gamma(shape + 1, rand)
return g * math.pow(rand() or 1e-12, 1 / shape)
d = shape - 1 / 3
c = 1 / math.sqrt(9 * d)
while True:
while True:
u1 = rand() or 1e-12
u2 = rand()
x = math.sqrt(-2 * math.log(u1)) * math.cos(2 * math.pi * u2)
v = 1 + c * x
if v > 0:
break
v = v * v * v
u = rand()
if u < 1 - 0.0331 * x ** 4 or math.log(u) < 0.5 * x * x + d * (1 - v + math.log(v)):
return d * v
def dirichlet(alpha, rand):
g = [gamma(max(a, 1e-6), rand) for a in alpha]
s = 0
for x in g:
s += x
return [x / s for x in g]
def _normalise(a):
s = 0
for x in a:
s = s + x
return [x / s for x in a]
# ---------------------------------------------------------------- 5. the probability source
class Params:
"""Chance probabilities and encounter outcomes, as arrays over D worlds.
mode "mean": D = 1, posterior means. mode "draw": D = len(seeds), one joint posterior draw per seed (each
distribution is drawn once, the first time it is needed, and reused, so a draw is one consistent world).
In draw mode each world draws its numbers in the order its own walk of the game first needs them (a branch with
probability exactly zero in that world is never walked), so call solver.draw_worlds() before using it.
chance(node, state) -> {outcome: array(D)}; encounter(ctx) -> {outcome: array(D)}.
"""
def __init__(self, T, mode="mean", seeds=(), alphas=None):
self.T, self.mode, self.alphas = T, mode, alphas or {}
self.rngs = [Rng(s) for s in seeds] if mode == "draw" else []
self.D = len(self.rngs) if mode == "draw" else 1
self.memo = {} # (node, level key) or ("enc", ctx) -> array (K, D)
self.filled = {} # same keys -> bool array (D,): which worlds have drawn this distribution
self.world = None # while drawing one world (see draw_world), its index
self._cache = {}
def _levels(self, node, state):
sp = CHANCE[node]
out = []
for L in range(len(sp["context"]) + 1):
names = sp["context"][:L]
if any(state.get(k) is None for k in names):
break
out.append(f"{L}:{ctx_key(state, names)}")
return out
def _get(self, mk, K, make_a):
"""The distribution for key mk: drawn (or computed) the first time it is needed, then reused."""
if self.mode == "mean":
if mk not in self.memo:
self.memo[mk] = np.array(_normalise(make_a(None)), dtype=float).reshape(K, 1)
return self.memo[mk]
if mk not in self.memo:
self.memo[mk] = np.zeros((K, self.D))
self.filled[mk] = np.zeros(self.D, dtype=bool)
d = self.world
if d is not None and not self.filled[mk][d]:
self.memo[mk][:, d] = dirichlet([float(x) for x in make_a(d)], self.rngs[d])
self.filled[mk][d] = True
return self.memo[mk]
def chance(self, node, state):
# once every world has been drawn, the answer depends only on the context values: cache it
ck = (node, tuple(state.get(k) for k in CHANCE[node]["context"]))
if self.world is None and ck in self._cache:
return self._cache[ck]
out = self._chance(node, state)
if self.world is None:
self._cache[ck] = out
return out
def _chance(self, node, state):
cats = CHANCE[node]["outcomes"]
al = self.alphas.get(node) or ALPHA
p = None
for key in self._levels(node, state):
c = self.T[node].get(key, {})
parent = p
def make_a(d, c=c, parent=parent):
if parent is None:
return [c.get(k, 0) + 0.5 for k in cats]
return [c.get(k, 0) + al * (parent[i] if d is None else parent[i][d]) for i, k in enumerate(cats)]
p = self._get((node, key), len(cats), make_a)
return dict(zip(cats, p))
def encounter(self, ctx):
e = self.T["encounter"].get(ctx, {"outcomes": {}, "seen": {}})
cats = [k for k in ENC_CATS if k == "burn" or e["seen"].get(k) or e["outcomes"].get(k, 0) > 0 or k == enc_colour(ctx)]
p = self._get(("enc", ctx), len(cats), lambda d: [e["outcomes"].get(k, 0) + 0.5 for k in cats])
return dict(zip(cats, p))