simthinkd 0.1.0__py3-none-any.whl

simthinkd/integrations/langchain_tool.py

@@ -0,0 +1,27 @@
+"""LangChain / LangGraph tool: route a step to a 2 ms decider instead of a model call.
+
+    pip install "simthinkd[langchain]"
+    from simthinkd.integrations.langchain_tool import simthinkd_tool
+    tool = simthinkd_tool("doom-defend")
+    tool.invoke({"state": "seen: Demon left a30 d5 | enemies 1 | sway left | gun ready | ammo25"})
+"""
+from ..core import Decider
+
+
+def simthinkd_tool(decider='doom-defend', name=None, description=None):
+    """A LangChain StructuredTool around one decider. Input: {"state": str}. Output: {"choice", "confidence", "ms"}."""
+    try:
+        from langchain_core.tools import StructuredTool
+    except ImportError as error:
+        raise ImportError('the LangChain tool needs: pip install "simthinkd[langchain]"') from error
+    d = decider if isinstance(decider, Decider) else Decider(decider)
+    actions = ', '.join(d.actions)
+
+    def run(state: str) -> dict:
+        r = d.decide(state)
+        return {'choice': r.choice, 'confidence': round(r.confidence, 4), 'ms': round(r.ms, 3)}
+
+    return StructuredTool.from_function(
+        run, name=name or f'simthinkd_{d.preset["name"].replace("-", "_")}',
+        description=description or (f'Pick one action ({actions}) for a short situation sentence in about 2 ms. '
+                                     f'Goal: {d.preset.get("goal", "")}'))

simthinkd/integrations/mcp_server.py

@@ -0,0 +1,52 @@
+"""MCP server: lets an agent (Claude Desktop, Cursor, any MCP client) ask a SimThink D decider for a fast decision.
+
+    pip install "simthinkd[mcp]"
+    python -m simthinkd.integrations.mcp_server            # stdio transport
+
+Client config example:
+    {"mcpServers": {"simthinkd": {"command": "python", "args": ["-m", "simthinkd.integrations.mcp_server"]}}}
+"""
+from functools import lru_cache
+
+from ..core import Decider, available
+
+
+@lru_cache(maxsize=8)
+def _decider(name):
+    return Decider(name)
+
+
+def list_deciders() -> dict:
+    """Bundled deciders and what each was trained for."""
+    return available()
+
+
+def decide(state: str, decider: str = 'doom-defend', actions: dict | None = None, goal: str | None = None) -> dict:
+    """Pick one action for a short situation sentence. Returns choice, confidence, probabilities and time in ms.
+
+    `actions` ({name: description}) and `goal` default to the ones the decider was trained with.
+    """
+    r = _decider(decider).decide(state, actions=actions, goal=goal)
+    return {'choice': r.choice, 'confidence': r.confidence, 'probabilities': r.probabilities, 'ms': round(r.ms, 3)}
+
+
+def build_server():
+    try:
+        from mcp.server.mcpserver import MCPServer as Server      # mcp 2.x
+    except ImportError:
+        try:
+            from mcp.server.fastmcp import FastMCP as Server      # mcp 1.x
+        except ImportError as error:
+            raise ImportError('the MCP server needs: pip install "simthinkd[mcp]"') from error
+    server = Server('simthinkd')
+    server.tool()(list_deciders)
+    server.tool()(decide)
+    return server
+
+
+def main():
+    build_server().run()
+
+
+if __name__ == '__main__':
+    main()

simthinkd/policy.py

@@ -0,0 +1,181 @@
+"""Goal/state/candidate encoder and portable learned policy; no task parser/oracle.
+
+All text is consumed by deterministic hashed word/character n-gram features.
+Neural projections, cross-candidate context and scores are learned from scratch.
+Hash compression is lossy; this is not a general pretrained language encoder.
+"""
+import hashlib
+import json
+import re
+import unicodedata
+from functools import lru_cache
+from pathlib import Path
+
+import numpy as np
+
+D = 192
+OPS = ['CLICK', 'TYPE_TEXT', 'SELECT', 'WAIT', 'SCROLL_DOWN', 'SCROLL_UP', 'DONE', 'BLOCKED']
+ROLES = ['link', 'button', 'textbox', 'searchbox', 'combobox', 'checkbox', 'option', 'radio']
+
+
+def tokens(text):
+    return re.findall(r'\w+|[^\w\s]', unicodedata.normalize('NFKC', str(text)).lower())
+
+
+@lru_cache(maxsize=60000)
+def hashed(text):
+    words = tokens(text)
+    features = ['w:' + t for t in words]
+    features += ['b:' + a + ' ' + b for a, b in zip(words, words[1:])]
+    features += ['c:' + t[i:i+3] for t in words for i in range(max(0, len(t)-2))]
+    result = np.zeros(D, np.float32)
+    for value in features:
+        number = int.from_bytes(hashlib.blake2s(value.encode(), digest_size=4).digest(), 'little')
+        result[number % D] += 1 if number & 256 else -1
+    result /= max(float(np.linalg.norm(result)), 1.)
+    return result
+
+
+def text(value):
+    return value if isinstance(value, str) else json.dumps(value, ensure_ascii=False, sort_keys=True)
+
+
+def without_indices(value):
+    if isinstance(value, dict):
+        return {k: without_indices(v) for k, v in value.items() if k != 'index'}
+    if isinstance(value, list):
+        return sorted([without_indices(v) for v in value], key=text)
+    return value
+
+
+def rows_for(body):
+    questions = body.get('questions', {})
+    if 'operation' not in questions:
+        raise ValueError('This decider answers operation/target questions only')
+    rows, operations = [], list(questions['operation']['criteria'])
+    for group, op in enumerate(operations):
+        head = op.lower() + '_target'
+        if head in questions:
+            for key, value in questions[head]['criteria'].items():
+                rows.append({'operation': op, 'target': key, 'head': head, 'group': group, 'criterion': value})
+        else:
+            rows.append({'operation': op, 'target': None, 'head': None, 'group': group,
+                         'criterion': {'element': op, 'description': questions['operation']['criteria'][op]}})
+    if not rows or len(rows) > 1500:
+        raise ValueError('Invalid offered action space')
+    return rows, operations
+
+
+def overlap(a, b):
+    aa, bb = set(tokens(a)), set(tokens(b))
+    return [len(aa & bb)/max(len(aa), 1), len(aa & bb)/max(len(bb), 1),
+            float(bool(str(b)) and str(b).casefold() in str(a).casefold())]
+
+
+def encode(body):
+    rows, operations = rows_for(body)
+    instructions = body['questions']['operation'].get('instructions', {})
+    goal = text(instructions.get('goal', ''))
+    state = body['state']
+    page = text(state.get('page', {}))
+    history = text(state.get('recent_actions', []))
+    page_state = state.get('page', {}) if isinstance(state.get('page', {}), dict) else {}
+    page_text = text(page_state.get('title', '')) + '\n' + text(page_state.get('text', ''))
+    recent = state.get('recent_actions') if isinstance(state.get('recent_actions'), list) else []
+    recent = [a for a in recent if isinstance(a, dict)]
+    # Order is preserved by the caller; the last entry is the most recent action.
+    recent_labels = [str(a.get('action', '')).strip().casefold() for a in recent]
+    last_changed = float(bool(recent[-1].get('page_changed'))) if recent else 0.
+    # Preserve all observed fields, removing only arbitrary indexing identities.
+    elements = without_indices(state.get('elements', []))
+    context = text(elements) + '\n' + text(instructions.get('rules', ''))
+    shared = [hashed(goal), hashed(page), hashed(history), hashed(context)]
+    goal_words = tokens(goal)
+    result = []
+    for row in rows:
+        c = row['criterion']
+        c = c if isinstance(c, dict) else {'element': text(c)}
+        label = re.sub(r'^\[[^\]]+\]\s*', '', c.get('element', ''))
+        value = text(c.get('current_value', ''))
+        local = text({**c, 'element': label, 'operation': row['operation']})
+        # Generic alignment windows retain order/negation context without parsing goals.
+        matching = set(tokens(label + ' ' + value))
+        positions = [i for i, word in enumerate(goal_words) if word in matching]
+        focus = ' | '.join(' '.join(goal_words[max(0, i-3):i+4]) for i in positions)
+        numeric = [float(row['operation'] == op) for op in OPS]
+        numeric += [float(c.get('role') == role) for role in ROLES]
+        numeric += [float(str(c.get(key, '')).lower() == flag)
+                    for key in ['checked', 'selected', 'expanded'] for flag in ['true', 'false']]
+        numeric += [float(bool(value)), min(len(rows), 100)/100., min(len(positions), 20)/20.]
+        numeric += overlap(goal, label) + overlap(goal, value) + overlap(page, label) + overlap(history, label)
+        # Generic pair interactions preserve comparison evidence before compression.
+        local_hash = hashed(local)
+        products = [hashed(goal)*local_hash, hashed(goal)*hashed(page), hashed(page)*local_hash]
+        def char_overlap(a, b):
+            def grams(v):
+                v = unicodedata.normalize('NFKC', str(v)).lower()
+                return {v[i:i+2] for i in range(max(0, len(v)-1)) if not v[i:i+2].isspace()}
+            aa, bb = grams(a), grams(b)
+            return [len(aa & bb)/max(len(aa), 1), len(aa & bb)/max(len(bb), 1)]
+        numeric += char_overlap(goal, label) + char_overlap(goal, page)
+        # Recency of this candidate itself: a bag overlap cannot tell order from count.
+        key = label.strip().casefold()
+        seen = [i for i, name in enumerate(recent_labels) if name and name == key]
+        distance = len(recent_labels) - 1 - seen[-1] if seen else None
+        numeric += [0. if distance is None else 1./(1.+distance),
+                    min(len(seen), 5)/5.,
+                    float(distance == 0),
+                    float(distance == 0)*last_changed,
+                    float(len(seen) >= 2),
+                    min(len(recent_labels), 10)/10.]
+        # DONE carries no target, so page agreement has to reach its own row explicitly.
+        is_done = float(row['operation'] == 'DONE')
+        page_match = overlap(goal, page_text) + char_overlap(goal, page_text)
+        numeric += page_match + [is_done*v for v in page_match]
+        result.append(np.concatenate([*shared, hashed(local), hashed(focus), *products, np.array(numeric, np.float32)]))
+    return np.stack(result), np.array([r['group'] for r in rows], np.int64), rows, operations
+
+
+def softmax(v):
+    ex = np.exp(v - np.max(v))
+    return ex / ex.sum()
+
+
+def distributions(scores, groups, temperature=1.):
+    scores = scores / temperature
+    op_scores, conditional = [], {}
+    for g in sorted(set(groups.tolist())):
+        where = np.flatnonzero(groups == g)
+        s = scores[where]
+        op_scores.append(float(np.max(s) + np.log(np.exp(s-np.max(s)).mean())))
+        conditional[g] = softmax(s)
+    op = softmax(np.asarray(op_scores))
+    joint = np.zeros(len(scores))
+    for g, p in conditional.items():
+        joint[groups == g] = op[g] * p
+    return op, conditional, joint
+
+
+class Policy:
+    def __init__(self, path):
+        self.path = Path(path)
+        self.digest = hashlib.sha256(self.path.read_bytes()).hexdigest()
+        with np.load(path, allow_pickle=False) as saved:
+            self.w = {key: saved[key].copy() for key in saved.files}
+        self.temperature = float(self.w.get('temperature', 1.))
+
+    def scores(self, x):
+        w = self.w
+        h = np.maximum(0, x @ w['local.weight'].T + w['local.bias'])
+        context = np.concatenate([h.mean(0), h.max(0)])
+        z = np.concatenate([h, np.broadcast_to(context, (len(h), len(context)))], axis=1)
+        z = np.maximum(0, z @ w['context.weight'].T + w['context.bias'])
+        return (z @ w['score.weight'].T + w['score.bias'])[:, 0]
+
+    def predict(self, body):
+        x, groups, rows, operations = encode(body)
+        op, conditional, joint = distributions(self.scores(x), groups, self.temperature)
+        chosen_group = int(op.argmax())
+        indices = np.flatnonzero(groups == chosen_group)
+        chosen = rows[int(indices[conditional[chosen_group].argmax()])]
+        return chosen, op, conditional, joint, rows, operations

simthinkd/server.py

@@ -0,0 +1,60 @@
+"""HTTP server for a decider (POST /v1/systemone, GET /health). Standard library + NumPy only.
+
+    simthinkd serve doom-defend --port 11890 [--delay-ms 0]
+
+Binds to 127.0.0.1 by default. `--delay-ms` adds a fixed wait after inference (latency-injection experiments).
+"""
+import json
+import time
+from datetime import datetime, timezone
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from .core import Decider
+
+
+def make_handler(decider, name, delay_ms):
+    class Handler(BaseHTTPRequestHandler):
+        protocol_version = 'HTTP/1.1'
+
+        def log_message(self, *unused):
+            pass
+
+        def _send(self, code, payload):
+            data = json.dumps(payload, ensure_ascii=False).encode()
+            self.send_response(code)
+            self.send_header('Content-Type', 'application/json')
+            self.send_header('Content-Length', str(len(data)))
+            self.end_headers()
+            self.wfile.write(data)
+
+        def do_GET(self):
+            if self.path != '/health':
+                return self._send(404, {'error': 'not found'})
+            self._send(200, {'model': name, 'weights_sha256': decider.sha256, 'delay_ms': delay_ms})
+
+        def do_POST(self):
+            if self.path != '/v1/systemone':
+                return self._send(404, {'error': 'not found'})
+            try:
+                body = json.loads(self.rfile.read(int(self.headers.get('Content-Length', 0))) or b'{}')
+                start = time.perf_counter()
+                answers = decider.predict(body)
+                infer_ms = (time.perf_counter() - start) * 1000
+            except (ValueError, KeyError, TypeError) as error:
+                return self._send(400, {'error': f'invalid request: {error}'})
+            if delay_ms:
+                time.sleep(delay_ms / 1000)
+            self._send(200, {'model': name, 'answers': answers, 'usage': {'external_model_calls': 0},
+                             'meta': {'total_ms': round(infer_ms + delay_ms, 3), 'infer_ms': round(infer_ms, 3),
+                                      'delay_ms': delay_ms, 'weights_sha256': decider.sha256,
+                                      'answered_at': datetime.now(timezone.utc).isoformat()}})
+
+    return Handler
+
+
+def serve(decider='doom-defend', host='127.0.0.1', port=11890, delay_ms=0.0, name=None):
+    decider = decider if isinstance(decider, Decider) else Decider(decider)
+    name = name or f'simthink-d:{decider.preset["name"]}'
+    server = ThreadingHTTPServer((host, port), make_handler(decider, name, delay_ms))
+    print(json.dumps({'listening': f'{host}:{port}', 'weights_sha256': decider.sha256, 'model': name}), flush=True)
+    server.serve_forever()

simthinkd/toy.py

@@ -0,0 +1,53 @@
+"""A toy domain for trying `simthinkd.fit` in seconds: a part passes an inspection station on a conveyor.
+
+    import simthinkd
+    from simthinkd import toy
+    d = simthinkd.fit(toy.examples(3000), toy.ACTIONS, goal=toy.GOAL, out="inspection")
+    d.decide("part: defect dent | severity severe | image clear | belt normal | rework queue long")
+
+Replace `observe()` and `teacher()` with your simulator's perception (exact state -> short binned sentence)
+and rule teacher (exact state -> action). That pair is all a new domain needs.
+"""
+import random
+
+GOAL = 'Ship only good parts without stopping the line.'
+ACTIONS = {
+    'PASS': 'Let the part continue to packing.',
+    'REJECT': 'Divert the part to the reject bin.',
+    'REWORK': 'Send the part to the rework loop.',
+    'SLOW_BELT': 'Slow the conveyor for a closer look.',
+    'ESCALATE': 'Hold the part and call a human inspector.',
+}
+
+
+def observe(rng):
+    """A random part: exact state (for the teacher) and its binned sentence (for the decider)."""
+    s = {'defect': rng.choice(['none'] * 5 + ['scratch', 'dent', 'missing', 'stain']),
+         'severity': rng.choice(['minor', 'moderate', 'severe']),
+         'image': rng.choice(['clear', 'blurry']),
+         'belt': rng.choice(['normal', 'fast']),
+         'queue': rng.choice(['short', 'long'])}
+    text = (f"part: defect {s['defect']} | severity {s['severity']} | image {s['image']} | "
+            f"belt {s['belt']} | rework queue {s['queue']}")
+    return s, text
+
+
+def teacher(s):
+    """The rule teacher the decider learns to imitate."""
+    if s['defect'] == 'none':
+        return 'SLOW_BELT' if s['image'] == 'blurry' and s['belt'] == 'fast' else 'PASS'
+    if s['image'] == 'blurry':
+        return 'ESCALATE'
+    if s['defect'] == 'stain' or (s['severity'] == 'minor' and s['queue'] == 'short'):
+        return 'REWORK'
+    return 'REJECT'
+
+
+def examples(n=3000, seed=0):
+    """n (situation sentence, teacher action) pairs."""
+    rng = random.Random(seed)
+    out = []
+    for _ in range(n):
+        s, text = observe(rng)
+        out.append((text, teacher(s)))
+    return out

simthinkd/train.py

@@ -0,0 +1,222 @@
+"""Train a decider from your own examples. Needs PyTorch (`pip install "simthinkd[train]"`); inference needs only NumPy.
+
+    import simthinkd
+    d = simthinkd.fit(examples, actions, goal="Ship only good parts.", out="my_decider")
+    d.decide("part: defect dent | severity severe | image clear")
+
+`examples` is a list of (situation sentence, action name) pairs, usually written by a rule teacher running in your
+simulator. The model is a randomly initialised small ranker (no pretrained weights), trained with sampled residual
+rewards against a proper scoring rule (Brier); the checkpoint with the lowest validation Brier is kept and its
+temperature is fitted on a separate calibration split. Splits are made by a hash of each example's id.
+
+Command line (folder of train/validation/calibration .jsonl.gz rows, see docs/TRAINING.md):
+    simthinkd train --data data/toy --out models/toy --steps 600
+"""
+import copy
+import gzip
+import hashlib
+import json
+import os
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+import numpy as np
+
+from .core import Decider, build_request
+from .policy import encode
+
+os.environ.setdefault('CUBLAS_WORKSPACE_CONFIG', ':4096:8')
+
+
+def _torch():
+    try:
+        import torch
+    except ImportError as error:
+        raise ImportError('training needs PyTorch: pip install "simthinkd[train]"') from error
+    return torch
+
+
+def sha(path):
+    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+
+
+def split_for(name):
+    digit = int(hashlib.sha256(name.encode()).hexdigest(), 16) % 10
+    return 'validation' if digit == 0 else 'calibration' if digit == 1 else 'train'
+
+
+def _ranker(torch, width):
+    class Ranker(torch.nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.local = torch.nn.Linear(width, 128)
+            self.context = torch.nn.Linear(128 * 3, 96)
+            self.score = torch.nn.Linear(96, 1)
+
+        def forward(self, x, mask):
+            h = torch.relu(self.local(x))
+            mean = (h * mask[..., None]).sum(1) / mask.sum(1, keepdim=True)
+            maximum = h.masked_fill(~mask[..., None], -1e9).max(1).values
+            c = torch.cat([mean, maximum], -1)[:, None].expand(-1, h.shape[1], -1)
+            return self.score(torch.relu(self.context(torch.cat([h, c], -1)))).squeeze(-1)
+    return Ranker()
+
+
+def _probabilities(torch, scores, groups, mask, temperature=1.):
+    scores = scores / temperature
+    membership = (groups[..., None] == torch.arange(8, device=scores.device)) & mask[..., None]
+    count = membership.sum(1)
+    expanded = scores[..., None].masked_fill(~membership, -1e9)
+    denom = torch.logsumexp(expanded, 1)
+    op_logits = (denom - count.clamp_min(1).log()).masked_fill(count == 0, -1e9)
+    op = torch.softmax(op_logits, -1)
+    conditional = torch.exp(expanded - denom[:, None]) * membership
+    return (conditional * op[:, None]).sum(-1), op
+
+
+def _encode_rows(torch, items, device):
+    features, groups, labels = [], [], []
+    for row in items:
+        x, g, candidates, _ = encode(row['request'])
+        gold = row['expected']
+        op = gold['operation']
+        target = gold.get(op.lower() + '_target')
+        matches = [i for i, c in enumerate(candidates) if (c['operation'], c['target']) == (op, target)]
+        if not matches:
+            raise ValueError(f'example {row.get("id")}: expected action {op!r} is not among the offered actions')
+        features.append(x)
+        groups.append(g)
+        labels.append(matches[0])
+    maximum = max(len(x) for x in features)
+    width = features[0].shape[1]
+    xx = np.zeros((len(items), maximum, width), np.float32)
+    gg = np.zeros((len(items), maximum), np.int64)
+    mm = np.zeros((len(items), maximum), bool)
+    for i, (x, g) in enumerate(zip(features, groups)):
+        xx[i, :len(x)] = x
+        gg[i, :len(x)] = g
+        mm[i, :len(x)] = True
+    return tuple(torch.as_tensor(v, device=device) for v in [xx, gg, mm, np.array(labels)]), width
+
+
+def _brier(torch, p, y):
+    q = torch.nn.functional.one_hot(y, p.shape[1]).float()
+    return ((p - q) ** 2).sum(-1).mean()
+
+
+def _assess(torch, model, part):
+    x, g, m, y = part
+    loss = 0.
+    with torch.inference_mode():
+        for start in range(0, len(x), 128):
+            sl = slice(start, start + 128)
+            p, _ = _probabilities(torch, model(x[sl], m[sl]), g[sl], m[sl])
+            loss += float(_brier(torch, p, y[sl])) * len(x[sl])
+    return loss / len(x)
+
+
+def _fit_one(torch, initial, train, validation, steps, seed, log):
+    model = copy.deepcopy(initial)
+    model.train()
+    optimizer = torch.optim.AdamW(model.parameters(), lr=.0015, weight_decay=.0001)
+    rng = torch.Generator(device=train[0].device).manual_seed(seed + 2121)
+    rewards = torch.Generator(device=train[0].device).manual_seed(seed + 7171)
+    x, g, mask, y = train
+    best, weights, events, best_step = float('inf'), copy.deepcopy(model.state_dict()), [], 0
+    started = time.perf_counter()
+    for step in range(steps + 1):
+        if step % 100 == 0 or step == steps:
+            val = _assess(torch, model, validation)
+            events.append({'step': step, 'validation_brier': val})
+            if step > 0 and val < best:
+                best, weights, best_step = val, copy.deepcopy(model.state_dict()), step
+            log({'seed': seed, 'step': step, 'validation_brier': round(val, 6)})
+        if step == steps:
+            break
+        batch = torch.randint(len(x), (96,), generator=rng, device=x.device)
+        p, _ = _probabilities(torch, model(x[batch], mask[batch]), g[batch], mask[batch])
+        q = torch.nn.functional.one_hot(y[batch], p.shape[1]).float()
+        reward = 2 * (q - p).detach()
+        baseline = (p.detach() * reward).sum(-1, keepdim=True)
+        sampled = torch.multinomial(p.detach(), 32, replacement=True, generator=rewards)
+        loss = -((reward - baseline).gather(1, sampled) * p.clamp_min(1e-30).log().gather(1, sampled)).mean()
+        optimizer.zero_grad(set_to_none=True)
+        loss.backward()
+        optimizer.step()
+    model.load_state_dict(weights)
+    model.eval()
+    return model, {'seed': seed, 'steps_run': steps, 'selected_step': best_step,
+                   'seconds': time.perf_counter() - started, 'validation_brier': best, 'events': events}
+
+
+def fit_rows(rows, out, steps=600, seed=31, card=None, quiet=False):
+    """Train from protocol rows {"id", "request", "expected": {"operation", "<op>_target"?}}; returns a Decider."""
+    torch = _torch()
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    log = (lambda record: None) if quiet else (lambda record: print(json.dumps(record), flush=True))
+    torch.set_num_threads(min(4, os.cpu_count() or 1))
+    torch.use_deterministic_algorithms(True)
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    splits = {'train': [], 'validation': [], 'calibration': []}
+    for row in rows:
+        splits[row.get('split') or split_for(row['id'])].append(row)
+    if min(len(v) for v in splits.values()) == 0:
+        raise ValueError('need enough examples for train/validation/calibration splits (about 100 or more)')
+    parts = {}
+    for name, items in splits.items():
+        parts[name], width = _encode_rows(torch, items, device)
+    torch.manual_seed(seed)
+    initial = _ranker(torch, width).to(device)
+    model, record = _fit_one(torch, initial, parts['train'], parts['validation'], steps, seed, log)
+    cx, cg, cm, cy = parts['calibration']
+    with torch.inference_mode():
+        scores = torch.cat([model(cx[i:i + 128], cm[i:i + 128]) for i in range(0, len(cx), 128)])
+        temperatures = np.geomspace(.5, 3., 25)
+        losses = [float(_brier(torch, _probabilities(torch, scores, cg, cm, float(t))[0], cy)) for t in temperatures]
+    temperature = float(temperatures[int(np.argmin(losses))])
+    arrays = {k: v.detach().cpu().numpy() for k, v in model.state_dict().items()}
+    path = out / 'weights.npz'
+    np.savez_compressed(path, **arrays, temperature=np.array(temperature))
+    card = dict(card or {})
+    card.update({'weights': path.name, 'sha256': sha(path), 'temperature': temperature,
+                 'parameters': sum(p.numel() for p in model.parameters()),
+                 'examples': {k: len(v) for k, v in splits.items()}, 'training': record,
+                 'calibration_brier': min(losses), 'device': device, 'torch': torch.__version__,
+                 'created_at': datetime.now(timezone.utc).isoformat(),
+                 'initialization': 'random (no pretrained weights)'})
+    (out / 'decider.json').write_text(json.dumps(card, ensure_ascii=False, indent=1), encoding='utf8')
+    return Decider(str(out))
+
+
+def fit(examples, actions, goal='', out='my_decider', steps=600, seed=31, name=None, quiet=False):
+    """Train a decider from (situation sentence, action name) pairs. Returns a ready Decider."""
+    if not actions or len(actions) > 8:
+        raise ValueError('offer between 1 and 8 actions: {name: short description}')
+    rows = []
+    for i, item in enumerate(examples):
+        state, action = (item['state'], item['action']) if isinstance(item, dict) else item
+        if action not in actions:
+            raise ValueError(f'example {i}: action {action!r} is not in actions')
+        row_id = f'ex{i:07d}:' + hashlib.sha256(state.encode()).hexdigest()[:8]
+        rows.append({'id': row_id, 'request': build_request(state, actions, goal), 'expected': {'operation': action}})
+    card = {'name': name or Path(out).name, 'actions': dict(actions), 'goal': goal,
+            'url': 'sim://custom', 'title': '', 'model': 'simthinkd'}
+    return fit_rows(rows, out, steps=steps, seed=seed, card=card, quiet=quiet)
+
+
+def fit_dir(data, out, steps=600, seed=31, quiet=False):
+    """Train from a folder holding train/validation/calibration .jsonl.gz protocol rows."""
+    rows = []
+    for split in ['train', 'validation', 'calibration']:
+        with gzip.open(Path(data) / f'{split}.jsonl.gz', 'rt', encoding='utf8') as stream:
+            rows += [dict(json.loads(line), split=split) for line in stream]
+    first = rows[0]['request']
+    card = {'name': Path(out).name, 'goal': first['questions']['operation'].get('instructions', {}).get('goal', ''),
+            'actions': {k: (v.get('description') if isinstance(v, dict) else v)
+                        for k, v in first['questions']['operation']['criteria'].items()},
+            'url': first['state']['page'].get('url', 'sim://custom'), 'title': first['state']['page'].get('title', ''),
+            'model': first.get('model', 'simthinkd'),
+            'data_sha256': {s: sha(Path(data) / f'{s}.jsonl.gz') for s in ['train', 'validation', 'calibration']}}
+    return fit_rows(rows, out, steps=steps, seed=seed, card=card, quiet=quiet)

simthinkd/weights/SHA256SUMS

@@ -0,0 +1,2 @@
+a164d90514f172ff2f1ac9452aaf83a637ffd8ef3136d0f553179e5c7ab035d8 *doom-corridor.npz
+a814587e03478f451f1ab478558de7e076dbe9a3de9cb2ee4cc84124cdfa2a19 *doom-defend.npz