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())