File size: 5,567 Bytes
0b92f59 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 | #!/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())
|