| """One RL run as one file (netherite configs/speedrun-grpo.yaml; Elliot, 2026-09-30: "two parts there. sim and |
| policy. with all the settings/hparams for each"). The grammar is netherite config.yaml's header, a strict YAML |
| subset read here line for line as native/src/worldconf.c and java WorldConf.java read it (stdlib only): |
| |
| sim: the world and the envs: netherite's registry (config.yaml lists every key at its default); |
| world: the C side (libnwrl, given the same file) reads and checks these values itself |
| seed: 1 |
| policy: the trainer's: POLICY below, every key with its default (nw_grpo's flag defaults) |
| grpo: |
| lr: 1e-05 |
| |
| A file without parts (configs/speedrun.yaml) is sim's sections alone and takes every policy default. Paths in |
| policy (model.ckpt, action.gui_head, out.dir) are under this checkout; sim.pipeline.start is under the netherite |
| tree (configs/'s parent). A key left out keeps its default; an unknown one is an error. |
| |
| uv run --no-project python -m mcsr.runconf FILE [key=value ...] # the resolved run file, every key |
| """ |
| import dataclasses |
| import os |
| import re |
| import sys |
|
|
| ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) |
| NETHERITE = os.path.expanduser(os.environ.get("NETHERITE", "~/dev/netherite-v2")) |
|
|
| HEADER = re.compile(r"([a-z][a-z0-9_]*):( +#.*| *)$") |
| SECTION2 = re.compile(r" ([a-z][a-z0-9_]*):( +#.*| *)$") |
| ENTRY = re.compile(r" ([a-z][a-z0-9_]*): ([A-Za-z0-9_./+,-]+)( +#.*| *)$") |
| ENTRY4 = re.compile(r" ([a-z][a-z0-9_]*): ([A-Za-z0-9_./+,-]+)( +#.*| *)$") |
| SYNTAX = "expected a part (sim: or policy:), a section (name:) or an entry (key: value) at its indent" |
|
|
|
|
| class ConfError(ValueError): |
| pass |
|
|
|
|
| def parse(text, name="-"): |
| """{part: {section: {key: value}}} in file order; a file without parts is {"sim": ...}""" |
| out = {} |
| parts, part, section = None, None, None |
| seen = set() |
| for n, line in enumerate(text.split("\n"), 1): |
| where = f"{name}:{n}" |
| if line.endswith("\r"): |
| line = line[:-1] |
| if "\t" in line: |
| raise ConfError(f"{where}: a tab (indent with spaces)") |
| t = line.strip() |
| if not t or t.startswith("#"): |
| continue |
| m = HEADER.match(line) |
| head = m is not None |
| if head: |
| h = m.group(1) |
| is_part = h in ("sim", "policy") |
| if parts is None: |
| parts = is_part |
| if not parts: |
| part = "sim" |
| out["sim"] = {} |
| if parts: |
| if not is_part: |
| raise ConfError(f"{where}: unknown part {h} (sim or policy)") |
| if h in out: |
| raise ConfError(f"{where}: part {h} twice") |
| part, section = h, None |
| out[h] = {} |
| continue |
| elif parts: |
| m = SECTION2.match(line) |
| head = m is not None |
| if head: |
| section = m.group(1) |
| if section in out[part]: |
| raise ConfError(f"{where}: section {section} twice") |
| out[part][section] = {} |
| continue |
| m = (ENTRY4 if parts else ENTRY).match(line) |
| if not m: |
| raise ConfError(f"{where}: {SYNTAX}") |
| if section is None: |
| raise ConfError(f"{where}: an entry before any section") |
| k = m.group(1) |
| if k in out[part][section]: |
| raise ConfError(f"{where}: {part}.{section}.{k} twice") |
| out[part][section][k] = m.group(2) |
| return out |
|
|
|
|
| |
|
|
| def sim_defaults(netherite=None): |
| path = os.path.join(netherite or NETHERITE, "config.yaml") |
| with open(path) as f: |
| return parse(f.read(), path)["sim"] |
|
|
|
|
| |
|
|
| @dataclasses.dataclass |
| class Model: |
| ckpt: str = "data/play_export/fast-D-s20000.pt" |
| edits: str = "none" |
| mode: str = "graph" |
| compile: str = "default" |
|
|
|
|
| @dataclasses.dataclass |
| class Placement: |
| cards: str = "1" |
| learner: str = "shared" |
| |
|
|
|
|
| @dataclasses.dataclass |
| class Action: |
| gui: str = "macro" |
| gui_head: str = "none" |
| gui_pointer: str = "slot" |
| gui_decide: str = "every_tick" |
| ops_per_step: int = 1 |
| camera: str = "mulaw41" |
| attack: str = "press" |
| act_every: int = 1 |
| |
|
|
|
|
| @dataclasses.dataclass |
| class Grpo: |
| objective: str = "logs" |
| iters: int = 40 |
| lr: float = 3e-6 |
| beta: float = 0.04 |
| clip: float = 0.2 |
| epochs: int = 1 |
| mb: int = 16 |
| stale: int = 0 |
| max_hours: float = 6.0 |
| seed: str = "none" |
| |
|
|
|
|
| @dataclasses.dataclass |
| class Reward: |
| """each term's weight, or "objective": the weight mcsr.rl.reward.OBJECTIVES[grpo.objective] gives it""" |
| items: str = "objective" |
| logs: str = "objective" |
| chest: str = "objective" |
| progress: str = "objective" |
| ach: str = "objective" |
| death: str = "objective" |
| milestone: str = "objective" |
| looted: str = "objective" |
|
|
|
|
| @dataclasses.dataclass |
| class Out: |
| dir: str = "none" |
|
|
|
|
| @dataclasses.dataclass |
| class Policy: |
| model: Model = dataclasses.field(default_factory=Model) |
| placement: Placement = dataclasses.field(default_factory=Placement) |
| action: Action = dataclasses.field(default_factory=Action) |
| grpo: Grpo = dataclasses.field(default_factory=Grpo) |
| reward: Reward = dataclasses.field(default_factory=Reward) |
| out: Out = dataclasses.field(default_factory=Out) |
|
|
|
|
| ENUMS = {"model.edits": ("version", "none"), "action.gui": ("macro", "head"), |
| "action.gui_pointer": ("slot", "item", "move", "recipe"), "action.gui_decide": ("every_tick", "on_op"), |
| "action.camera": ("mulaw41", "target"), "action.attack": ("press", "hold"), "grpo.stale": (0, 1)} |
|
|
| |
| |
| UNIMPLEMENTED = {} |
|
|
|
|
| def _typed(typ, v, key): |
| try: |
| return typ(v) |
| except ValueError: |
| raise ConfError(f"policy.{key} takes a {typ.__name__}, not {v}") from None |
|
|
|
|
| def _check_reward(key, v): |
| if v != "objective": |
| try: |
| float(v) |
| except ValueError: |
| raise ConfError(f"policy.{key} takes a number or objective, not {v}") from None |
|
|
|
|
| @dataclasses.dataclass |
| class Run: |
| sim: dict |
| policy: Policy |
| path: str = "" |
|
|
| |
| @property |
| def worlds(self): |
| return int(self.sim["pipeline"]["worlds"]) |
|
|
| @property |
| def groups(self): |
| return int(self.sim["pipeline"]["groups"]) |
|
|
| @property |
| def sim_cards(self): |
| return [int(c) for c in self.sim["pipeline"]["cards"].split(",")] |
|
|
| @property |
| def episode_seconds(self): |
| return int(self.sim["pipeline"]["episode_seconds"]) |
|
|
| def get(self, key): |
| """part.section.key""" |
| part, section, k = key.split(".") |
| if part == "sim": |
| return self.sim[section][k] |
| return getattr(getattr(self.policy, section), k) |
|
|
| def set(self, key, v): |
| """part.section.key=value: refused for a key the file's registry does not have""" |
| part, _, rest = key.partition(".") |
| section, _, k = rest.partition(".") |
| if part == "sim": |
| if section not in self.sim or k not in self.sim[section]: |
| raise ConfError(f"unknown key {key}") |
| self.sim[section][k] = str(v) |
| return |
| if part != "policy" or not hasattr(self.policy, section) or not hasattr(getattr(self.policy, section), k): |
| raise ConfError(f"unknown key {key}") |
| sec = getattr(self.policy, section) |
| f = {f.name: f for f in dataclasses.fields(sec)}[k] |
| if section == "reward": |
| v = str(v) |
| _check_reward(f"{section}.{k}", v) |
| else: |
| v = _typed(f.type, v, f"{section}.{k}") if f.type is not str else str(v) |
| if f"{section}.{k}" == "grpo.seed" and v != "none" and not re.fullmatch(r"-?[0-9]{1,19}", v): |
| raise ConfError(f"policy.grpo.seed takes none or an integer, not {v}") |
| if f"{section}.{k}" == "placement.learner" and v not in ("shared", "card") and not re.fullmatch(r"[0-9]{1,2}", v): |
| raise ConfError(f"policy.placement.learner takes shared, card or a card's ordinal, not {v}") |
| allowed = ENUMS.get(f"{section}.{k}") |
| if allowed and v not in allowed: |
| raise ConfError(f"policy.{section}.{k} takes {'|'.join(map(str, allowed))}, not {v}") |
| setattr(sec, k, v) |
|
|
| def check_implemented(self): |
| for k, want in UNIMPLEMENTED.items(): |
| if self.get("policy." + k) != want: |
| raise ConfError(f"policy.{k}: not implemented yet ({want}, the default, is today's behaviour)") |
| |
| for k, val, lever in (("action.attack", "hold", "hold_attack"), ("action.camera", "target", "look_target")): |
| if self.get("policy." + k) == val and self.sim.get("actions", {}).get(lever) != "on": |
| raise ConfError(f"policy.{k} {val} needs sim.actions.{lever} on") |
| if self.policy.action.act_every < 1 or (self.policy.action.act_every > 1 and |
| self.sim.get("client", {}).get("ticks_per_step") != "1"): |
| raise ConfError("policy.action.act_every takes 1, or K > 1 with sim.client.ticks_per_step 1") |
|
|
| def reward_weights(self, objectives): |
| """the reward's weights: OBJECTIVES[grpo.objective] with this file's numbers over it""" |
| w = dict(objectives[self.policy.grpo.objective]) |
| for f in dataclasses.fields(self.policy.reward): |
| v = getattr(self.policy.reward, f.name) |
| if v != "objective": |
| w[f.name] = float(v) |
| return w |
|
|
| def root(self): |
| """the netherite tree the sim part's relative paths are under: the file's directory, configs/'s parent""" |
| d = os.path.dirname(os.path.abspath(self.path)) if self.path else NETHERITE |
| return os.path.dirname(d) if os.path.basename(d) == "configs" else d |
|
|
| def policy_path(self, p): |
| """a policy path under this checkout; "none" is none""" |
| if p in ("none", ""): |
| return "" |
| return p if os.path.isabs(p) else os.path.join(ROOT, p) |
|
|
| def text(self): |
| """the resolved run file: both parts, every key""" |
| lines = [f"# resolved by mcsr.runconf from {self.path or '(defaults)'}", "", "sim:"] |
| for section, kv in self.sim.items(): |
| lines.append(f" {section}:") |
| lines += [f" {k}: {v}" for k, v in kv.items()] |
| lines += ["", "policy:"] |
| for sf in dataclasses.fields(self.policy): |
| lines.append(f" {sf.name}:") |
| sec = getattr(self.policy, sf.name) |
| for f in dataclasses.fields(sec): |
| v = getattr(sec, f.name) |
| lines.append(f" {f.name}: {v!r}" if isinstance(v, float) else f" {f.name}: {v}") |
| return "\n".join(lines) + "\n" |
|
|
|
|
| def load(path, netherite=None): |
| """the run file at path (either form) over every default; ConfError names the file and line""" |
| with open(path) as f: |
| parts = parse(f.read(), path) |
| sim = sim_defaults(netherite) |
| for section, kv in parts.get("sim", {}).items(): |
| if section not in sim: |
| raise ConfError(f"{path}: unknown section sim.{section}") |
| for k, v in kv.items(): |
| if k not in sim[section]: |
| raise ConfError(f"{path}: unknown key sim.{section}.{k}") |
| sim[section][k] = v |
| run = Run(sim=sim, policy=Policy(), path=os.path.abspath(path)) |
| for section, kv in parts.get("policy", {}).items(): |
| if not hasattr(run.policy, section): |
| raise ConfError(f"{path}: unknown section policy.{section}") |
| for k, v in kv.items(): |
| try: |
| run.set(f"policy.{section}.{k}", v) |
| except ConfError as e: |
| raise ConfError(f"{path}: {e}") from None |
| return run |
|
|
|
|
| def resolve(a, flags, netherite=None, old=None, name="nw_grpo"): |
| """a driver's run: the run file (a.run, else a.config, else NETHERITE/configs/speedrun.yaml) under every flag |
| given (a.FLAG not None; flags maps a flag to its key, None for --config), printed as an override when there is a |
| run file. Without a run file a flag not given takes the driver's old default (old: {flag: value}), so the flags |
| alone run as they did. --n is a sim card's share of sim.pipeline.worlds: the cards are set first. Exits with the |
| message on any error.""" |
| if a.run and a.config: |
| sys.exit(f"{name}: --run FILE is the config too (its sim part); drop --config") |
| path = a.run or a.config or os.path.join(netherite or NETHERITE, "configs/speedrun.yaml") |
| try: |
| run = load(path, netherite) |
| if not a.run: |
| for k, v in (old or {}).items(): |
| if getattr(a, k) is None: |
| setattr(a, k, v) |
| given = {k: v for k, v in vars(a).items() if flags.get(k) and v is not None} |
| for k in sorted(given, key=lambda k: k != "sims"): |
| v = given[k] |
| if k == "n": |
| v = v * len(run.sim_cards) |
| elif k == "seconds": |
| if v != int(v): |
| sys.exit(f"{name}: --seconds {v}: sim.pipeline.episode_seconds is whole seconds") |
| v = int(v) |
| elif k in ("edits", "gui_head", "learner"): |
| v = v or ("shared" if k == "learner" else "none") |
| elif k in ("start", "out", "ckpt"): |
| v = os.path.abspath(v) |
| if a.run: |
| print(f"{name}: override {flags[k]} = {v} (--{k.replace('_', '-')})", flush=True) |
| run.set(flags[k], v) |
| run.check_implemented() |
| except ConfError as e: |
| sys.exit(f"{name}: {e}") |
| if run.worlds % len(run.sim_cards): |
| sys.exit(f"{name}: sim.pipeline.worlds {run.worlds} is not a whole number a card of {run.sim_cards}") |
| if run.policy.out.dir == "none": |
| sys.exit(f"{name}: no out dir (policy.out.dir or --out)") |
| return run |
|
|
|
|
| def main(): |
| if len(sys.argv) < 2: |
| sys.exit(__doc__) |
| try: |
| run = load(sys.argv[1]) |
| for kv in sys.argv[2:]: |
| k, _, v = kv.partition("=") |
| run.set(k, v) |
| except ConfError as e: |
| sys.exit(f"runconf: {e}") |
| sys.stdout.write(run.text()) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
