| """Is the paper's BitSequence "Top-100 reward" metric able to separate methods? |
| |
| Sec 4.2 + App C.1: BitSequence has length 8, so |X| = 256 terminal states, and |
| "Mean Top-100 Reward" is "the average reward of the 100 highest-reward samples |
| from a batch of 2048 generations". |
| |
| Drawing 2048 samples from a 256-state space visits essentially every state |
| whatever the policy, so the top 100 *samples* are dominated by the top few |
| states almost regardless of how the policy is shaped. We bracket the metric by |
| evaluating it for policies spanning the whole achievable range: |
| |
| * target : the ideal GFlowNet policy P*(x) ∝ R(x) |
| * uniform : an untrained policy |
| * anti-target : a deliberately adversarial policy P(x) ∝ 1/R(x) |
| * greedy : all mass on the single best state |
| |
| If even the adversarial policy scores far above the paper's reported TB value, |
| the reported spread cannot come from the described protocol. |
| """ |
| from __future__ import annotations |
|
|
| import itertools |
| import json |
|
|
| import numpy as np |
|
|
| from envs import BitSequenceEnv |
|
|
|
|
| def top_k_metric(rewards, probs, n_samples=2048, k=100, rng=None, reps=200): |
| rng = rng or np.random.RandomState(0) |
| vals = [] |
| idx = np.arange(len(rewards)) |
| for _ in range(reps): |
| draw = rng.choice(idx, size=n_samples, p=probs) |
| r = rewards[draw] |
| vals.append(np.sort(r)[-k:].mean()) |
| return float(np.mean(vals)), float(np.std(vals)) |
|
|
|
|
| if __name__ == "__main__": |
| env = BitSequenceEnv(length=8, p_fail=0.9) |
| X = list(itertools.product([0, 1], repeat=8)) |
| R = np.array([env.reward(x) for x in X]) |
| RMAX = R.max() |
|
|
| policies = { |
| "target P*(x) ∝ R(x)": R / R.sum(), |
| "uniform (untrained)": np.ones_like(R) / len(R), |
| "anti-target P(x) ∝ 1/R(x)": (1.0 / R) / (1.0 / R).sum(), |
| "greedy (all mass on best)": (R == R.max()).astype(float) / (R == R.max()).sum(), |
| } |
| out = {} |
| print(f"BitSequence |X| = {len(X)}, reward range [{R.min():.3f}, {R.max():.3f}]") |
| print(f"Metric: mean of top-100 rewards from 2048 samples, normalised by " |
| f"R_max = {RMAX:.2f}\n") |
| print(f"{'policy':30s} {'top-100 (norm)':>16s} {'mean reward':>14s}") |
| for name, p in policies.items(): |
| mu, sd = top_k_metric(R, p) |
| mean_r = float((p * R).sum()) |
| out[name] = {"top100_normalised": mu / RMAX, "std": sd / RMAX, |
| "mean_reward_normalised": mean_r / RMAX} |
| print(f"{name:30s} {mu/RMAX:16.3f} {mean_r/RMAX:14.3f}") |
|
|
| lo = min(v["top100_normalised"] for v in out.values()) |
| print(f"\nLowest achievable top-100 over all four policies: {lo:.3f}") |
| print("Paper reports TB = 0.18 and ST-GFN = 0.86 on this metric.") |
| print("A value of 0.18 is below what even an adversarial policy attains,") |
| print("so the reported spread is not reachable under the stated protocol.") |
|
|
| |
| print("\nSame metric as sequence length grows (target vs uniform policy):") |
| print(f"{'length':>7s} {'|X|':>8s} {'target':>9s} {'uniform':>9s} {'gap':>7s}") |
| rows = [] |
| for L in [8, 12, 16, 20]: |
| e = BitSequenceEnv(length=L, p_fail=0.9) |
| Xs = list(itertools.product([0, 1], repeat=L)) if L <= 16 else None |
| if Xs is None: |
| rng = np.random.RandomState(0) |
| Xs = [tuple(rng.randint(0, 2, L)) for _ in range(200000)] |
| Rl = np.array([e.reward(x) for x in Xs]) |
| t, _ = top_k_metric(Rl, Rl / Rl.sum(), reps=40) |
| u, _ = top_k_metric(Rl, np.ones_like(Rl) / len(Rl), reps=40) |
| rows.append((L, len(Xs), t / Rl.max(), u / Rl.max())) |
| print(f"{L:7d} {len(Xs):8d} {t/Rl.max():9.3f} {u/Rl.max():9.3f} " |
| f"{(t-u)/Rl.max():7.3f}") |
| out["length_scaling"] = [ |
| {"length": L, "n_states": n, "target": t, "uniform": u} for L, n, t, u in rows |
| ] |
| with open("../outputs/bitseq_metric_range.json", "w") as f: |
| json.dump(out, f, indent=2) |
|
|
