SoulFireMage's picture
Release training/verification code after unblinding
020f489 verified
Raw History Blame Contribute Delete
6.08 kB
"""PPO trainer for the weight-reading probe.
The policy is the network under study: 500 -> 32 -> 32 -> 5, tanh, PyTorch default init.
The value function is a SEPARATE network, so no shared trunk contaminates the policy weights.
Identical hyperparameters for every game (see CONFIG).
"""
import argparse, json, time
import numpy as np, torch, torch.nn as nn
from games import GAMES, random_returns
CONFIG = dict(
total_steps=20_000_000, n_envs=128, n_steps=128, epochs=4, minibatches=4,
lr=2.5e-4, gamma=0.99, gae_lambda=0.95, clip=0.2, ent_coef=0.01, vf_coef=0.5,
max_grad_norm=0.5, eval_episodes=500,
# Competence gate (frozen before launch): trained mean return must exceed the
# random-policy mean by >= 1.0 AND Welch t-statistic must exceed 3.3 (p < ~0.001).
gate_min_diff=1.0, gate_min_t=3.3,
)
def policy_net():
return nn.Sequential(nn.Linear(500, 32), nn.Tanh(), nn.Linear(32, 32), nn.Tanh(), nn.Linear(32, 5))
def value_net():
return nn.Sequential(nn.Linear(500, 64), nn.Tanh(), nn.Linear(64, 64), nn.Tanh(), nn.Linear(64, 1))
def weights_dict(pi):
sd = pi.state_dict()
names = {"0.weight": "fc1.weight", "0.bias": "fc1.bias", "2.weight": "fc2.weight",
"2.bias": "fc2.bias", "4.weight": "out.weight", "4.bias": "out.bias"}
return {names[k]: v.detach().cpu().numpy().astype(np.float32) for k, v in sd.items()}
@torch.no_grad()
def evaluate(pi, game, episodes, seed):
env = GAMES[game](64, seed)
obs = env.reset(); ep = np.zeros(64); out = []
while len(out) < episodes:
logits = pi(torch.as_tensor(obs))
a = torch.distributions.Categorical(logits=logits).sample().numpy()
obs, r, d = env.step(a)
ep += r
for i in np.where(d)[0]:
out.append(ep[i]); ep[i] = 0
return np.array(out[:episodes])
def train(game, seed, total_steps=None, log_every=50):
c = dict(CONFIG)
if total_steps:
c["total_steps"] = total_steps
torch.manual_seed(seed); np.random.seed(seed)
torch.set_num_threads(1)
pi, vf = policy_net(), value_net()
opt = torch.optim.Adam(list(pi.parameters()) + list(vf.parameters()), lr=c["lr"], eps=1e-5)
env = GAMES[game](c["n_envs"], seed)
obs = torch.as_tensor(env.reset())
N, T = c["n_envs"], c["n_steps"]
iters = c["total_steps"] // (N * T)
ep_ret = np.zeros(N); recent = []
t0 = time.time()
for it in range(iters):
frac = 1 - it / iters
for g in opt.param_groups:
g["lr"] = c["lr"] * frac
bo, ba, blp, br, bd, bv = [], [], [], [], [], []
with torch.no_grad():
for _ in range(T):
logits = pi(obs); dist = torch.distributions.Categorical(logits=logits)
a = dist.sample(); v = vf(obs).squeeze(-1)
nobs, r, d = env.step(a.numpy())
bo.append(obs); ba.append(a); blp.append(dist.log_prob(a)); bv.append(v)
br.append(torch.as_tensor(r)); bd.append(torch.as_tensor(d, dtype=torch.float32))
ep_ret += r
for i in np.where(d)[0]:
recent.append(ep_ret[i]); ep_ret[i] = 0
obs = torch.as_tensor(nobs)
last_v = vf(obs).squeeze(-1)
adv = torch.zeros(T, N); gae = torch.zeros(N)
for t in reversed(range(T)):
nv = last_v if t == T - 1 else bv[t + 1]
nonterm = 1 - bd[t]
delta = br[t] + c["gamma"] * nv * nonterm - bv[t]
gae = delta + c["gamma"] * c["gae_lambda"] * nonterm * gae
adv[t] = gae
ret = adv + torch.stack(bv)
O = torch.stack(bo).reshape(T * N, 500); A = torch.stack(ba).reshape(-1)
LP = torch.stack(blp).reshape(-1); ADV = adv.reshape(-1); RET = ret.reshape(-1)
mb = (T * N) // c["minibatches"]
for _ in range(c["epochs"]):
perm = torch.randperm(T * N)
for s in range(0, T * N, mb):
j = perm[s:s + mb]
dist = torch.distributions.Categorical(logits=pi(O[j]))
lp = dist.log_prob(A[j]); ratio = (lp - LP[j]).exp()
ad = (ADV[j] - ADV[j].mean()) / (ADV[j].std() + 1e-8)
pl = -torch.min(ratio * ad, ratio.clamp(1 - c["clip"], 1 + c["clip"]) * ad).mean()
vl = ((vf(O[j]).squeeze(-1) - RET[j]) ** 2).mean()
loss = pl + c["vf_coef"] * vl - c["ent_coef"] * dist.entropy().mean()
opt.zero_grad(); loss.backward()
nn.utils.clip_grad_norm_(list(pi.parameters()) + list(vf.parameters()), c["max_grad_norm"])
opt.step()
if it % log_every == 0 or it == iters - 1:
m = np.mean(recent[-200:]) if recent else float("nan")
sps = (it + 1) * N * T / (time.time() - t0)
print(f"[{game} s{seed}] it {it}/{iters} steps {(it+1)*N*T:,} return {m:.2f} sps {sps:,.0f}", flush=True)
trained = evaluate(pi, game, c["eval_episodes"], seed + 10_000)
rand = random_returns(game, c["eval_episodes"], seed + 20_000)
diff = trained.mean() - rand.mean()
t = diff / np.sqrt(trained.var(ddof=1) / len(trained) + rand.var(ddof=1) / len(rand) + 1e-12)
stats = dict(game=game, seed=seed, steps=iters * N * T, trained_mean=float(trained.mean()),
trained_sd=float(trained.std()), random_mean=float(rand.mean()),
random_sd=float(rand.std()), diff=float(diff), welch_t=float(t),
passes_gate=bool(diff >= c["gate_min_diff"] and t >= c["gate_min_t"]),
wall_seconds=time.time() - t0, config=c)
return pi, stats
if __name__ == "__main__":
ap = argparse.ArgumentParser()
ap.add_argument("--game", required=True); ap.add_argument("--seed", type=int, default=0)
ap.add_argument("--steps", type=int, default=None); ap.add_argument("--out", default=None)
a = ap.parse_args()
pi, stats = train(a.game, a.seed, a.steps)
print(json.dumps({k: v for k, v in stats.items() if k != "config"}, indent=1))
if a.out:
np.savez(a.out, **weights_dict(pi))