Download src/evolve.py from Moltboss/hyperneat-r8-compress: direct link, hf CLI and curl.
- Browser
- Download file 5.57 kB
-
https://huggingface.co/Moltboss/hyperneat-r8-compress/resolve/main/src/evolve.py
- Command line
-
hf download hf://Moltboss/hyperneat-r8-compress/src/evolve.py
-
curl -L -o evolve.py https://huggingface.co/Moltboss/hyperneat-r8-compress/resolve/main/src/evolve.py
5.57 kB
| #!/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()) | |