#!/usr/bin/env python3 """Evolve a HyperNEAT CPPN keep-mask + instance order for an HN5 store.""" from __future__ import annotations import argparse, hashlib, json, lzma, sys, time, zlib from pathlib import Path sys.path.insert(0, str(Path(__file__).resolve().parent)) import jax, jax.numpy as jnp, numpy as np from codec import decode_store, encode_store, identity_baselines, ship_tier from hyperneat import N_PARAMS, cppn_keys, theta_bytes, theta_from_bytes from r8_fixture import build_fixture ROOT = Path(__file__).resolve().parents[1] DEFAULT_OUT = ROOT / "artifacts" SHIP_TIER = 5 def keep_mask(theta, n_res, true_live): keys = np.asarray(cppn_keys(jnp.asarray(theta, dtype=jnp.float32), n_res)) return np.logical_or(keys > 0.0, true_live) def kept_blobs(blobs, mask): return [b for b, k in zip(blobs, mask) if bool(k)] def instance_order(theta, n): keys = np.asarray(cppn_keys(jnp.asarray(theta, dtype=jnp.float32), n)) return np.argsort(keys, kind="stable") def packed(blobs, true_live, theta): mask = keep_mask(theta, len(blobs), true_live) kept = kept_blobs(blobs, mask) if not kept: return 0, "empty", b"", kept order = instance_order(theta, len(kept)) ordered = [kept[int(i)] for i in order] size, name, store = encode_store(ordered) return size, name, store, kept def roundtrip_ok(kept, store, theta): try: ordered = decode_store(store) except (ValueError, OSError, lzma.LZMAError, zlib.error): return False if len(ordered) != len(kept): return False order = instance_order(theta, len(kept)) back = [b""] * len(kept) for pos, src in enumerate(order): back[int(src)] = ordered[pos] return back == kept def evolve(seed, pop, gens, out_dir): fix = build_fixture() blobs = [r.blob for r in fix.resources] true_live = np.array([r.true_live for r in fix.resources], dtype=bool) live_concat = b"".join(r.blob for r in fix.resources if r.true_live) r8_opt, r8_over = fix.r8_opt_zlib(), fix.r8_overkeep_zlib() bases = identity_baselines(live_concat) identity_lzma = bases["lzma6"] rng = np.random.default_rng(seed) thetas = rng.normal(0.0, 0.25, size=(pop, N_PARAMS)).astype(np.float32) drop = np.zeros(N_PARAMS, dtype=np.float32); drop[-1] = -4.0 thetas[0] = drop if pop > 1: thetas[1] = 0.0 history = [] best_theta = thetas[0].copy() best_size, best_codec, best_store, best_kept = packed(blobs, true_live, best_theta) t0, sigma, stalled = time.time(), 0.12, 0 for g in range(gens): sizes = np.empty(pop, dtype=np.int32) codecs, stores, kepts = [], [], [] for i in range(pop): s, c, st, k = packed(blobs, true_live, thetas[i]) sizes[i] = s; codecs.append(c); stores.append(st); kepts.append(k) order = np.argsort(sizes, kind="stable") thetas, sizes = thetas[order], sizes[order] codecs = [codecs[i] for i in order]; stores = [stores[i] for i in order]; kepts = [kepts[i] for i in order] if int(sizes[0]) < best_size: best_size = int(sizes[0]); best_theta = thetas[0].copy(); best_codec = codecs[0]; best_store = stores[0]; best_kept = kepts[0] stalled = 0; sigma = max(0.03, sigma * 0.92) else: stalled += 1; sigma = min(0.45, sigma * 1.12) history.append({"gen": g, "best": int(sizes[0]), "sigma": round(sigma, 4)}) if stalled >= 4: break elite_n = max(2, pop // 8) children = [thetas[i].copy() for i in range(elite_n)] while len(children) < pop: parent = thetas[int(rng.integers(0, elite_n))] child = parent + rng.normal(0.0, sigma, size=N_PARAMS).astype(np.float32) if rng.random() < 0.08: child = rng.normal(0.0, 0.35, size=N_PARAMS).astype(np.float32); child[-1] -= 2.0 children.append(child.astype(np.float32)) thetas = np.stack(children, axis=0) assert roundtrip_ok(best_kept, best_store, best_theta) assert keep_mask(best_theta, len(blobs), true_live)[true_live].all() tier = ship_tier(size=best_size, r8_opt=r8_opt, identity_lzma=identity_lzma, roundtrip=True, live_ok=True) out_dir.mkdir(parents=True, exist_ok=True) (out_dir / "cppn_theta.f16").write_bytes(theta_bytes(best_theta)) (out_dir / "kept_reordered.hn5").write_bytes(best_store) report = {"seed": seed, "pop": pop, "gens_ran": len(history), "n_params": N_PARAMS, "codec": best_codec, "ship_tier": tier, "publishable": tier >= SHIP_TIER, "r8_opt_zlib9": r8_opt, "identity_lzma6": identity_lzma, "hyperneat_kept_store": best_size, "delta_vs_identity_lzma": best_size - identity_lzma, "rel_vs_identity_lzma": round((identity_lzma - best_size) / float(identity_lzma), 4), "roundtrip": True, "jax": jax.__version__, "history": history} (out_dir / "benchmark.json").write_text(json.dumps(report, indent=2) + "\n") return report def main(): p = argparse.ArgumentParser() p.add_argument("--seed", type=int, default=7) p.add_argument("--pop", type=int, default=16) p.add_argument("--gens", type=int, default=12) p.add_argument("--out", type=Path, default=DEFAULT_OUT) p.add_argument("--min-tier", type=int, default=SHIP_TIER) args = p.parse_args() report = evolve(args.seed, args.pop, args.gens, args.out) print(json.dumps({k: report[k] for k in report if k != "history"}, indent=2)) return 0 if report["ship_tier"] >= args.min_tier else 3 if __name__ == "__main__": raise SystemExit(main())