File size: 6,081 Bytes
020f489 | 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 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | """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))
|