SoulFireMage's picture
Release training/verification code after unblinding
020f489 verified
Raw History Blame Contribute Delete
11.6 kB
"""Four vectorised 10x10 grid games for the weight-reading probe.
Shared interface for every game:
obs: float32 [B, 5, 10, 10], flattened channel-major to [B, 500]
ch0 agent, ch1 moving objects, ch2 reward targets, ch3 obstacles,
ch4 previous frame of ch1 (moving objects one step ago)
actions: 0 no-op, 1 up, 2 down, 3 left, 4 right (row 0 is the top)
step(a) -> obs, reward [B], done [B]; finished envs auto-reset.
"""
import numpy as np
H = W = 10
DR = np.array([0, -1, 1, 0, 0])
DC = np.array([0, 0, 0, -1, 1])
class _Base:
max_steps = 1000
def __init__(self, n, seed):
self.n = n
self.rng = np.random.default_rng(seed)
self.t = np.zeros(n, np.int64)
self.prev_moving = np.zeros((n, H, W), np.float32)
self._reset(np.ones(n, bool))
self.prev_moving[:] = self._moving()
def reset(self):
return self._obs()
def _obs(self):
o = np.zeros((self.n, 5, H, W), np.float32)
o[:, 0] = self._agent()
o[:, 1] = self._moving()
o[:, 2] = self._targets()
o[:, 3] = self._obstacles()
o[:, 4] = self.prev_moving
return o.reshape(self.n, 500)
def step(self, a):
a = np.asarray(a)
before = self._moving()
r, done = self._step(a)
self.t += 1
done = done | (self.t >= self.max_steps)
self.prev_moving = before
if done.any():
self._reset(done)
self.t[done] = 0
self.prev_moving[done] = self._moving()[done]
return self._obs(), r.astype(np.float32), done
def _onehot(self, rows, cols, mask=None):
g = np.zeros((self.n, H, W), np.float32)
idx = np.arange(self.n)
if mask is None:
mask = np.ones(self.n, bool)
g[idx[mask], rows[mask], cols[mask]] = 1
return g
class Breakout(_Base):
"""Paddle (2 wide) on bottom row; bricks in rows 0-2; lose ball = episode end."""
def _reset(self, m):
k = m.sum()
if not hasattr(self, "px"):
n = self.n
self.px = np.zeros(n, int); self.bx = np.zeros(n, int); self.by = np.zeros(n, int)
self.dx = np.zeros(n, int); self.dy = np.zeros(n, int)
self.bricks = np.zeros((n, 3, W), bool)
self.px[m] = self.rng.integers(0, 9, k)
self.bx[m] = self.rng.integers(0, W, k)
self.by[m] = self.rng.integers(3, 5, k)
self.dx[m] = self.rng.choice([-1, 1], k)
self.dy[m] = 1
self.bricks[m] = True
def _step(self, a):
n = self.n; idx = np.arange(n)
self.px = np.clip(self.px + DC[a], 0, 8)
r = np.zeros(n); done = np.zeros(n, bool)
nx = self.bx + self.dx
hitw = (nx < 0) | (nx > 9)
self.dx[hitw] *= -1
nx = np.where(hitw, self.bx + self.dx, nx)
ny = self.by + self.dy
top = ny < 0
self.dy[top] = 1
ny = np.where(top, self.by + 1, ny)
inb = ny <= 2
hitb = np.zeros(n, bool)
hitb[inb] = self.bricks[idx[inb], ny[inb], nx[inb]]
self.bricks[idx[hitb], ny[hitb], nx[hitb]] = False
r[hitb] += 1
self.dy[hitb] *= -1
ny = np.where(hitb, self.by, ny)
bottom = ny >= 9
caught = bottom & ((nx == self.px) | (nx == self.px + 1))
self.dy[caught] = -1
ny = np.where(caught, self.by, ny)
done |= bottom & ~caught
self.bx, self.by = nx, ny
cleared = ~self.bricks.reshape(n, -1).any(1)
self.bricks[cleared] = True
return r, done
def _agent(self):
g = self._onehot(np.full(self.n, 9), self.px)
g[np.arange(self.n), 9, self.px + 1] = 1
return g
def _moving(self):
return self._onehot(np.clip(self.by, 0, 9), self.bx)
def _targets(self):
g = np.zeros((self.n, H, W), np.float32)
g[:, 0:3] = self.bricks
return g
def _obstacles(self):
return np.zeros((self.n, H, W), np.float32)
class Pong(_Base):
"""Agent paddle (3 tall) at right column; opponent paddle (obstacle) at left."""
def _reset(self, m):
if not hasattr(self, "py"):
n = self.n
self.py = np.zeros(n, int); self.oy = np.zeros(n, int)
self.score_a = np.zeros(n, int); self.score_o = np.zeros(n, int)
self.bx = np.zeros(n, int); self.by = np.zeros(n, int)
self.dx = np.zeros(n, int); self.dy = np.zeros(n, int)
self.py[m] = 3; self.oy[m] = 3
self.score_a[m] = 0; self.score_o[m] = 0
self._serve(m)
def _serve(self, m):
k = m.sum()
self.bx[m] = self.rng.integers(4, 6, k)
self.by[m] = self.rng.integers(2, 8, k)
self.dx[m] = self.rng.choice([-1, 1], k)
self.dy[m] = self.rng.choice([-1, 1], k)
def _step(self, a):
n = self.n
self.py = np.clip(self.py + DR[a], 0, 7)
follow = self.rng.random(n) < 0.7
centre = self.oy + 1
mv = np.sign(self.by - centre) * follow
self.oy = np.clip(self.oy + mv, 0, 7)
r = np.zeros(n)
ny = self.by + self.dy
hw = (ny < 0) | (ny > 9)
self.dy[hw] *= -1
ny = np.where(hw, self.by + self.dy, ny)
nx = self.bx + self.dx
right = nx >= 9
hit_a = right & (ny >= self.py) & (ny <= self.py + 2)
left = nx <= 0
hit_o = left & (ny >= self.oy) & (ny <= self.oy + 2)
self.dx[hit_a | hit_o] *= -1
nx = np.where(hit_a | hit_o, self.bx, nx)
miss_a = right & ~hit_a
miss_o = left & ~hit_o
r[miss_a] -= 1; r[miss_o] += 1
self.score_a += miss_o; self.score_o += miss_a
self.bx, self.by = nx, ny
point = miss_a | miss_o
if point.any():
self._serve(point)
done = (self.score_a >= 5) | (self.score_o >= 5)
return r, done
def _agent(self):
g = np.zeros((self.n, H, W), np.float32)
for k in range(3):
g[np.arange(self.n), self.py + k, 9] = 1
return g
def _moving(self):
return self._onehot(self.by, np.clip(self.bx, 0, 9))
def _targets(self):
return np.zeros((self.n, H, W), np.float32)
def _obstacles(self):
g = np.zeros((self.n, H, W), np.float32)
for k in range(3):
g[np.arange(self.n), self.oy + k, 0] = 1
return g
class Freeway(_Base):
"""Agent crosses 8 lanes of traffic (rows 1-8) from row 9 to row 0."""
max_steps = 250
def _reset(self, m):
k = m.sum()
if not hasattr(self, "ay"):
n = self.n
self.ax = np.full(n, 4); self.ay = np.zeros(n, int)
self.carx = np.zeros((n, 8), int); self.cdir = np.zeros((n, 8), int)
self.cper = np.ones((n, 8), int)
self.ay[m] = 9
self.carx[m] = self.rng.integers(0, W, (k, 8))
self.cdir[m] = self.rng.choice([-1, 1], (k, 8))
self.cper[m] = self.rng.integers(1, 4, (k, 8))
def _step(self, a):
n = self.n; idx = np.arange(n)
self.ay = np.clip(self.ay + DR[a], 0, 9)
moving = (self.t[:, None] % self.cper) == 0
self.carx = (self.carx + self.cdir * moving) % W
lane = self.ay - 1
inlane = (lane >= 0) & (lane < 8)
hit = np.zeros(n, bool)
hit[inlane] = self.carx[idx[inlane], lane[inlane]] == self.ax[inlane]
self.ay = np.where(hit, np.minimum(self.ay + 2, 9), self.ay)
r = np.zeros(n)
home = self.ay == 0
r[home] = 1
self.ay[home] = 9
return r, np.zeros(n, bool)
def _agent(self):
return self._onehot(self.ay, self.ax)
def _moving(self):
g = np.zeros((self.n, H, W), np.float32)
for l in range(8):
g[np.arange(self.n), l + 1, self.carx[:, l]] = 1
return g
def _targets(self):
g = np.zeros((self.n, H, W), np.float32)
g[:, 0, :] = 1
return g
def _obstacles(self):
return np.zeros((self.n, H, W), np.float32)
MAZE = [
"##########",
"#........#",
"#.##..##.#",
"#.#....#.#",
"#...##...#",
"#.#....#.#",
"#.##..##.#",
"#........#",
"#........#",
"##########",
]
WALLS = np.array([[c == "#" for c in row] for row in MAZE])
class PacMan(_Base):
"""Agent collects pellets in a walled maze; two ghosts chase; touching one ends the episode."""
max_steps = 500
def _reset(self, m):
k = m.sum()
if not hasattr(self, "ar"):
n = self.n
self.ar = np.zeros(n, int); self.ac = np.zeros(n, int)
self.gr = np.zeros((n, 2), int); self.gc = np.zeros((n, 2), int)
self.pel = np.zeros((n, H, W), bool)
self.ar[m] = 8; self.ac[m] = self.rng.integers(1, 9, k)
self.gr[m] = 1; self.gc[m] = np.stack([np.full(k, 1), np.full(k, 8)], 1)
self.pel[m] = ~WALLS
mi = np.where(m)[0]
self.pel[mi, self.ar[mi], self.ac[mi]] = False
def _step(self, a):
n = self.n; idx = np.arange(n)
r0, c0 = self.ar.copy(), self.ac.copy()
nr, nc = self.ar + DR[a], self.ac + DC[a]
ok = ~WALLS[nr, nc]
self.ar = np.where(ok, nr, self.ar); self.ac = np.where(ok, nc, self.ac)
r = self.pel[idx, self.ar, self.ac].astype(float)
self.pel[idx, self.ar, self.ac] = False
g_old_r, g_old_c = self.gr.copy(), self.gc.copy()
for g in range(2):
moves = self.rng.random(n) < 0.6
cr = self.gr[:, g, None] + DR[None, 1:]
cc = self.gc[:, g, None] + DC[None, 1:]
valid = ~WALLS[cr, cc]
dist = np.abs(cr - self.ar[:, None]) + np.abs(cc - self.ac[:, None])
dist = np.where(valid, dist, 999).astype(float)
greedy = np.argmin(dist + self.rng.random((n, 4)) * 0.1, 1)
rnd_score = np.where(valid, self.rng.random((n, 4)), -1)
randm = np.argmax(rnd_score, 1)
choice = np.where(self.rng.random(n) < 0.7, greedy, randm)
self.gr[:, g] = np.where(moves, cr[idx, choice], self.gr[:, g])
self.gc[:, g] = np.where(moves, cc[idx, choice], self.gc[:, g])
same = ((self.gr == self.ar[:, None]) & (self.gc == self.ac[:, None])).any(1)
swap = ((g_old_r == self.ar[:, None]) & (g_old_c == self.ac[:, None]) &
(self.gr == r0[:, None]) & (self.gc == c0[:, None])).any(1)
done = same | swap
cleared = ~self.pel.reshape(n, -1).any(1)
self.pel[cleared] = ~WALLS
return r, done
def _agent(self):
return self._onehot(self.ar, self.ac)
def _moving(self):
g = np.zeros((self.n, H, W), np.float32)
for k in range(2):
g[np.arange(self.n), self.gr[:, k], self.gc[:, k]] = 1
return g
def _targets(self):
return self.pel.astype(np.float32)
def _obstacles(self):
return np.broadcast_to(WALLS.astype(np.float32), (self.n, H, W)).copy()
GAMES = {"breakout": Breakout, "pong": Pong, "pacman": PacMan, "freeway": Freeway}
def random_returns(name, episodes=500, seed=0):
env = GAMES[name](64, seed)
rng = np.random.default_rng(seed + 1)
ep_ret = np.zeros(64); out = []
while len(out) < episodes:
_, r, d = env.step(rng.integers(0, 5, 64))
ep_ret += r
for i in np.where(d)[0]:
out.append(ep_ret[i]); ep_ret[i] = 0
return np.array(out[:episodes])
if __name__ == "__main__":
for g in GAMES:
x = random_returns(g)
print(f"{g:9s} random: mean {x.mean():6.2f} sd {x.std():5.2f}")