| """JevSpatial: an evaluation-only benchmark of games and spatial relations where CODE computes the consequences and the |
| model decides (the game code works out what each move would do, words it, and the model answers one question per |
| move). Every gold label is computed by the generators below. Gold is exact. |
| |
| Skills (every item carries "split"): |
| - game_q: the consequence is written INSIDE each yes/no question ("Moving up: the snake moves closer to the food. |
| Should the snake move up?") over a minimal status state. One noul per move; gold true for the best move(s). |
| Items carry "pick": the scorer also reports whether argmax P(yes) over the moves is a best move. |
| - game_s: the same situations with the consequences in the STATE ({"if the snake moves up": ...}), plain questions |
| ("Is moving up a good move?" per move, plus a choice over the moves when one move is strictly best). |
| - game_rule: the situation is in the state, the rule in the question ("A cactus within 60 px must be jumped over. |
| Should the dinosaur jump now?"): a noul per option and a choice. |
| - spatial_coord: relations from coordinates in the state (left / right / above / below, which is nearer under a stated |
| metric, inside a rectangle, which move reduces the distance, within a distance). |
| - spatial_grid: ASCII grids 5x5 to 9x9 with a legend (relative position, free cell, counts in a row / column, |
| adjacency). |
| |
| Games: Snake and Dino ("seen_game") and Breakout, Whac-A-Mole, Knife Hit, 2048, Tetris, Pac-Man ("unseen_game": games |
| whose mechanics differ from the common ones, a generalisation split). |
| """ |
|
|
| import gzip |
| import hashlib |
| import json |
| import random |
| from collections import deque |
|
|
| import bench_common as X |
| from bench_common import choice, noul, noul_target, onehot, score as score_q |
|
|
| VERSION = "v1" |
| BENCH = "JevSpatial" |
| LICENSE = "CC0-1.0 (generated by code)" |
| SKILLS = ("game_q", "game_s", "game_rule", "spatial_coord", "spatial_grid") |
| SEEN = ("Snake", "Dino") |
| UNSEEN = ("Breakout", "Whac-A-Mole", "Knife Hit", "2048", "Tetris", "Pac-Man") |
| SIZES = {"game_q": 440, "game_s": 440, "game_rule": 320, "spatial_coord": 420, "spatial_grid": 420} |
| |
| GAME_N = {"Snake": 130, "Dino": 70, "Breakout": 40, "Whac-A-Mole": 40, "Knife Hit": 40, "2048": 40, "Tetris": 40, |
| "Pac-Man": 40} |
| RULE_N = {"Dino": 110, "Breakout": 70, "Whac-A-Mole": 70, "Pac-Man": 70} |
|
|
| DIRS = {"up": (-1, 0), "down": (1, 0), "left": (0, -1), "right": (0, 1)} |
|
|
|
|
| def split_of(game: str) -> str: |
| return "seen_game" if game in SEEN else "unseen_game" |
|
|
|
|
| def _item(id, skill, game, state, questions, targets, pick=False, source=None): |
| st = state if isinstance(state, str) else json.dumps(state, ensure_ascii=False) |
| key = st + " " + " ".join(q["instructions"] for q in questions.values()) |
| it = X._item(id, skill, source or f"spatial:{skill}:{game}", st, questions, targets, LICENSE, key) |
| it.update(bench=BENCH, split=split_of(game) if game in SEEN + UNSEEN else "generic", pick=pick) |
| return it |
|
|
|
|
| |
| |
| |
| def _mv(id, gerund, ask, ask_s, subj, effect, rank, good): |
| return {"id": id, "gerund": gerund, "ask": ask, "ask_s": ask_s, "subj": subj, "effect": effect, "rank": rank, |
| "good": good} |
|
|
|
|
| def _finish(game, unit, status, moves): |
| good = [m for m in moves if m["good"]] |
| if not good or len(good) == len(moves) or len({m["rank"] for m in good}) != 1: |
| return None |
| if min(m["rank"] for m in good) <= max([m["rank"] for m in moves if not m["good"]] or [-1]): |
| return None |
| return {"game": game, "unit": unit, "status": status, "moves": moves} |
|
|
|
|
| def _bfs(blocked, start, goal, n): |
| seen = {start: 0} |
| q = deque([start]) |
| while q: |
| r, c = q.popleft() |
| if (r, c) == goal: |
| return seen[(r, c)] |
| for dr, dc in DIRS.values(): |
| nb = (r + dr, c + dc) |
| if 0 <= nb[0] < n and 0 <= nb[1] < n and nb not in blocked and nb not in seen: |
| seen[nb] = seen[(r, c)] + 1 |
| q.append(nb) |
| return None |
|
|
|
|
| def snake_moves(walk, food, n): |
| """The four moves of a snake (cells tail first, head last) on an n x n board with the consequence of each.""" |
| head = walk[-1] |
| d0 = _bfs(set(walk[1:]), head, food, n) |
| moves = [] |
| for name, (dr, dc) in DIRS.items(): |
| new = (head[0] + dr, head[1] + dc) |
| if not (0 <= new[0] < n and 0 <= new[1] < n): |
| eff, rank = "would crash into a wall and die", 0 |
| elif new in walk[1:]: |
| eff, rank = "would run into its own body and die", 0 |
| elif new == food: |
| eff, rank = "would eat the food", 4 |
| else: |
| d1 = _bfs(set(walk[1:]), new, food, n) |
| if d1 is None: |
| eff, rank = "would be cut off, with no free path left to the food", 1 |
| elif d0 is not None and d1 < d0: |
| eff, rank = "moves closer to the food", 3 |
| else: |
| eff, rank = "moves farther from the food", 2 |
| moves.append(_mv(name, f"Moving {name}", f"Should the snake move {name}?", f"Is moving {name} a good move?", |
| f"if the snake moves {name}", eff, rank, rank >= 3)) |
| return moves |
|
|
|
|
| def snake_sit(rng): |
| n = rng.randint(8, 12) |
| for _ in range(50): |
| cell = (rng.randrange(n), rng.randrange(n)) |
| walk = [cell] |
| target = rng.randint(3, 16) |
| while len(walk) < target: |
| opts = [(walk[-1][0] + dr, walk[-1][1] + dc) for dr, dc in DIRS.values()] |
| opts = [o for o in opts if 0 <= o[0] < n and 0 <= o[1] < n and o not in walk] |
| if not opts: |
| break |
| walk.append(rng.choice(opts)) |
| if len(walk) >= 3: |
| break |
| else: |
| return None |
| free = [(r, c) for r in range(n) for c in range(n) if (r, c) not in walk] |
| food = rng.choice(free) |
| moves = snake_moves(walk, food, n) |
| eaten = len(walk) - 3 |
| status = {"game": "Snake", "board": f"{n}x{n}", "length": len(walk), "apples eaten": max(0, eaten), |
| "turn": rng.randint(len(walk), 400)} |
| return _finish("Snake", "the snake", status, moves) |
|
|
|
|
| DINO_OBS = {"small cactus": "cactus", "tall cactus": "cactus", "cactus cluster": "cactus", "high bird": "high", |
| "low bird": "low"} |
|
|
|
|
| def dino_sit(rng): |
| obs = rng.choice(list(DINO_OBS) + ["clear"] * 1) |
| phase = "clear" if obs == "clear" else rng.choice(["far", "now", "now"]) |
| status = {"game": "Dino", "score": rng.randint(20, 3000), "speed": rng.choice(["slow", "medium", "fast"])} |
| return _finish("Dino", "the dinosaur", status, dino_moves(obs, phase)) |
|
|
|
|
| def dino_moves(obs, phase): |
| """jump / duck / run for the next obstacle `obs` (or "clear") in phase clear | far | now (act now).""" |
| need = "run" if phase in ("clear", "far") else ("duck" if DINO_OBS.get(obs) == "high" else "jump") |
| eff = {} |
| if phase == "clear": |
| eff = {"run": "keeps running along a clear track", "jump": "jumps although nothing is in the way and loses speed", |
| "duck": "ducks although nothing is in the way and loses speed"} |
| elif phase == "far": |
| eff = {"run": f"keeps running; the {obs} is still far away", "jump": f"jumps too early and lands before the {obs}", |
| "duck": f"ducks too early and stands up again before the {obs} arrives"} |
| else: |
| kind = DINO_OBS[obs] |
| eff = {"run": f"runs straight into the {obs}"} |
| if kind == "high": |
| eff["duck"] = f"passes safely under the {obs}" |
| eff["jump"] = f"jumps right into the {obs}" |
| else: |
| eff["jump"] = f"jumps over the {obs} and clears it" |
| eff["duck"] = f"ducks and is hit by the {obs}" if kind == "low" else f"ducks and runs into the {obs}" |
| verbs = {"jump": ("Jumping", "jump", "jumping"), "duck": ("Ducking", "duck", "ducking"), |
| "run": ("Continuing to run", "keep running", "continuing to run")} |
| moves = [] |
| for m in ("jump", "duck", "run"): |
| g, v, ing = verbs[m] |
| sentence = "Should the dinosaur " + ("keep running" if m == "run" else f"{v} now") + "?" |
| moves.append(_mv(m, g, sentence, f"Is {ing} a good move?", f"if the dinosaur {'keeps running' if m == 'run' else m + 's'}", |
| eff[m], 2 if m == need else 0, m == need)) |
| return moves |
|
|
|
|
| def breakout_sit(rng): |
| W = 200 |
| w = rng.choice([30, 40, 50, 60]) |
| step = rng.choice([10, 15, 20, 25]) |
| p = rng.randrange(w // 2, W - w // 2 + 1, 5) |
| x_l = rng.randrange(10, W - 9, 5) |
| moves = breakout_moves(p, x_l, w, step, W) |
| status = {"game": "Breakout", "lives": rng.randint(1, 5), "bricks left": rng.randint(5, 60)} |
| return _finish("Breakout", "the paddle", status, moves) |
|
|
|
|
| def breakout_moves(p, x_l, w, step, W=200): |
| """left / stay / right for a paddle centred at p (width w, `step` px per move) and a ball landing at x_l.""" |
| moves = [] |
| for name, d in (("left", -1), ("stay", 0), ("right", 1)): |
| p2 = min(W - w // 2, max(w // 2, p + d * step)) |
| if abs(p2 - x_l) <= w // 2: |
| eff, rank = "ends under the ball, which it returns", 2 |
| elif abs(p2 - x_l) < abs(p - x_l): |
| eff, rank = "gets closer to the ball's landing spot but still misses the ball", 1 |
| elif name == "stay": |
| eff, rank = "stays where it is and the ball falls past it", 0 |
| else: |
| eff, rank = "moves away from the ball's landing spot and the ball is lost", 0 |
| g = {"left": "Moving the paddle left", "stay": "Keeping the paddle still", "right": "Moving the paddle right"}[name] |
| ask = {"left": "Should the paddle move left?", "stay": "Should the paddle stay where it is?", |
| "right": "Should the paddle move right?"}[name] |
| asks = {"left": "Is moving the paddle left a good move?", "stay": "Is keeping the paddle still a good move?", |
| "right": "Is moving the paddle right a good move?"}[name] |
| sj = {"left": "if the paddle moves left", "stay": "if the paddle stays still", "right": "if the paddle moves right"}[name] |
| moves.append(_mv(name, g, ask, asks, sj, eff, rank, rank == 2)) |
| return moves |
|
|
|
|
| HOLES = ["top-left", "top-middle", "top-right", "middle-left", "center", "middle-right", "bottom-left", "bottom-middle", |
| "bottom-right"] |
|
|
|
|
| def mole_sit(rng): |
| k = rng.choice([4, 4, 5]) |
| holes = rng.sample(HOLES, k) |
| n_good = rng.choice([1, 1, 2]) |
| kinds = ["mole"] * n_good + [rng.choice(["bomb", "empty", "bomb"]) for _ in range(k - n_good)] |
| rng.shuffle(kinds) |
| status = {"game": "Whac-A-Mole", "score": rng.randint(0, 80), "lives": rng.randint(1, 3)} |
| return _finish("Whac-A-Mole", "the hammer", status, mole_moves(holes, kinds)) |
|
|
|
|
| def mole_moves(holes, kinds): |
| """One move per hole; kinds[i] is mole | bomb | empty.""" |
| eff = {"mole": ("hits a mole and scores a point", 3), "bomb": ("hits a bomb and loses a life", 0), |
| "empty": ("swings at an empty hole and wastes the turn", 1)} |
| moves = [] |
| for h, kd in zip(holes, kinds, strict=True): |
| e, r = eff[kd] |
| moves.append(_mv(h.replace("-", "_"), f"Hitting the {h} hole", f"Should the player hit the {h} hole?", |
| f"Is hitting the {h} hole a good move?", f"if the player hits the {h} hole", e, r, kd == "mole")) |
| return moves |
|
|
|
|
| def knife_sit(rng): |
| slots = 12 |
| stuck = set(rng.sample(range(slots), rng.randint(3, 8))) |
| waits = ["now", "after one beat", "after two beats", "after three beats"] |
| moves = [] |
| for k, label in enumerate(waits): |
| hit = k in stuck |
| e, r = ("hits a knife already stuck in the log and bounces off", 0) if hit else ("sticks in a free spot of the log", 2) |
| moves.append(_mv(f"t{k}", f"Throwing {label}", f"Should the player throw the knife {label}?", |
| f"Is throwing {label} a good move?", f"if the player throws {label}", e, r, not hit)) |
| status = {"game": "Knife Hit", "stage": rng.randint(1, 30), "knives left": rng.randint(2, 9)} |
| return _finish("Knife Hit", "the knife", status, moves) |
|
|
|
|
| def _slide_line(line): |
| vals = [v for v in line if v] |
| out, gain, i = [], 0, 0 |
| while i < len(vals): |
| if i + 1 < len(vals) and vals[i] == vals[i + 1]: |
| out.append(vals[i] * 2) |
| gain += vals[i] * 2 |
| i += 2 |
| else: |
| out.append(vals[i]) |
| i += 1 |
| return out + [0] * (len(line) - len(out)), gain |
|
|
|
|
| def _move2048(b, d): |
| nb, gain = [], 0 |
| if d in ("left", "right"): |
| for row in b: |
| r = row[::-1] if d == "right" else row |
| s, g = _slide_line(r) |
| nb.append(s[::-1] if d == "right" else s) |
| gain += g |
| return nb, gain |
| cols = [] |
| for c in range(4): |
| col = [b[r][c] for r in range(4)] |
| col = col[::-1] if d == "down" else col |
| s, g = _slide_line(col) |
| cols.append(s[::-1] if d == "down" else s) |
| gain += g |
| return [[cols[c][r] for c in range(4)] for r in range(4)], gain |
|
|
|
|
| def g2048_sit(rng): |
| b = [[0] * 4 for _ in range(4)] |
| for _ in range(rng.randint(6, 12)): |
| b[rng.randrange(4)][rng.randrange(4)] = rng.choice([2, 2, 4, 4, 8, 16, 32, 64]) |
| res = {d: _move2048(b, d) for d in DIRS} |
| best = max(g for _, g in res.values()) |
| if best == 0: |
| return None |
| moves = [] |
| for d, (nb, g) in res.items(): |
| if g == best: |
| e, r = f"merges tiles for the most points available (+{g})", 3 |
| elif g > 0: |
| e, r = f"merges tiles but for fewer points than the best move (+{g})", 2 |
| elif nb != b: |
| e, r = "slides the tiles without merging any", 1 |
| else: |
| e, r = "changes nothing because no tile can move that way", 0 |
| moves.append(_mv(d, f"Swiping {d}", f"Should the player swipe {d}?", f"Is swiping {d} a good move?", |
| f"if the player swipes {d}", e, r, g == best)) |
| status = {"game": "2048", "score": rng.randint(100, 20000), "biggest tile": max(max(r) for r in b)} |
| return _finish("2048", "the move", status, moves) |
|
|
|
|
| def tetris_sit(rng): |
| Wd, H = 6, 12 |
| for _ in range(400): |
| heights = [rng.randint(2, 5) for _ in range(Wd)] |
| occ = set() |
| for c in range(Wd): |
| for y in range(heights[c]): |
| if y == heights[c] - 1 or rng.random() < 0.9: |
| occ.add((y, c)) |
| piece = rng.choice(["O", "I"]) |
| plc = [] |
| if piece == "O": |
| plc = [("O", c, [(0, 0), (0, 1), (1, 0), (1, 1)], f"the 2x2 square in columns {c + 1}-{c + 2}") for c in range(Wd - 1)] |
| else: |
| plc = [("Ih", c, [(0, i) for i in range(4)], f"the I bar lying flat in columns {c + 1}-{c + 4}") for c in range(Wd - 3)] |
| plc += [("Iv", c, [(i, 0) for i in range(4)], f"the I bar standing up in column {c + 1}") for c in range(Wd)] |
| res = [] |
| for tag, c, cells, label in plc: |
| y = H |
| while y > 0 and all((y - 1 + dy, c + dx) not in occ and 0 <= c + dx < Wd for dy, dx in cells): |
| y -= 1 |
| placed = {(y + dy, c + dx) for dy, dx in cells} |
| holes = 0 |
| for col in {cc for _, cc in placed}: |
| low = min(r for r, cc in placed if cc == col) |
| top_below = max([r for r, cc in occ if cc == col and r < low] or [-1]) |
| holes += low - top_below - 1 |
| full = occ | placed |
| lines = sum(all((r, c2) in full for c2 in range(Wd)) for r in range(H)) |
| res.append((tag + str(c), label, lines, holes)) |
| clear = [r for r in res if r[2] > 0] |
| if not clear or len({r[2] for r in clear}) != 1: |
| continue |
| others = [r for r in res if r[2] == 0] |
| if len(others) < 2: |
| continue |
| pick = rng.sample(clear, min(len(clear), rng.choice([1, 1, 2]))) + rng.sample(others, min(len(others), 3)) |
| rng.shuffle(pick) |
| moves = [] |
| for mid, label, lines, holes in pick: |
| if lines: |
| e, r = f"clears {lines} line" + ("s" if lines > 1 else ""), 3 |
| elif holes: |
| e, r = f"leaves {holes} hole" + ("s" if holes > 1 else "") + " under it and clears no line", 0 |
| else: |
| e, r = "fits flat but clears no line", 1 |
| moves.append(_mv(mid, f"Placing {label}", f"Should the piece be placed as {label}?", |
| f"Is placing {label} a good move?", f"if the piece is placed as {label}", e, r, lines > 0)) |
| status = {"game": "Tetris", "piece": "O square" if piece == "O" else "I bar", "level": rng.randint(1, 15), |
| "lines": rng.randint(0, 200)} |
| return _finish("Tetris", "the piece", status, moves) |
| return None |
|
|
|
|
| def pacman_sit(rng): |
| n = 7 |
| walls = {(r, c) for r in range(n) for c in range(n) if rng.random() < 0.22} |
| free = [(r, c) for r in range(n) for c in range(n) if (r, c) not in walls] |
| if len(free) < 12: |
| return None |
| pac = rng.choice(free) |
| ghosts = rng.sample([f for f in free if abs(f[0] - pac[0]) + abs(f[1] - pac[1]) >= 2], rng.choice([1, 2])) |
| dots = {f for f in free if f != pac and f not in ghosts and rng.random() < 0.55} |
| moves = [] |
| for d, (dr, dc) in DIRS.items(): |
| new = (pac[0] + dr, pac[1] + dc) |
| if not (0 <= new[0] < n and 0 <= new[1] < n) or new in walls: |
| e, r = "bumps into a wall and does not move", 1 |
| elif new in ghosts: |
| e, r = "runs straight into a ghost and loses a life", 0 |
| elif any(abs(g[0] - new[0]) + abs(g[1] - new[1]) <= 1 for g in ghosts): |
| e, r = "moves next to a ghost, which catches Pac-Man next turn", 0 |
| elif new in dots: |
| e, r = "eats a dot", 3 |
| else: |
| e, r = "moves onto an empty cell without a dot", 2 |
| moves.append(_mv(d, f"Moving {d}", f"Should Pac-Man move {d}?", f"Is moving {d} a good move?", |
| f"if Pac-Man moves {d}", e, r, r == 3)) |
| status = {"game": "Pac-Man", "lives": rng.randint(1, 3), "dots left": len(dots) + rng.randint(0, 100)} |
| return _finish("Pac-Man", "Pac-Man", status, moves) |
|
|
|
|
| SIT_GEN = {"Snake": snake_sit, "Dino": dino_sit, "Breakout": breakout_sit, "Whac-A-Mole": mole_sit, |
| "Knife Hit": knife_sit, "2048": g2048_sit, "Tetris": tetris_sit, "Pac-Man": pacman_sit} |
|
|
|
|
| def make_situations(game: str, n: int, seed: int) -> list: |
| """n situations of `game`, spread evenly over the position of the (first) best move; deterministic in seed.""" |
| rng = random.Random(f"{seed}:{game}") |
| cands, seen = [], set() |
| tries = 0 |
| while len(cands) < 8 * n and tries < 400 * n: |
| tries += 1 |
| s = SIT_GEN[game](rng) |
| if s is None: |
| continue |
| sig = json.dumps(s, sort_keys=True) |
| if sig in seen: |
| continue |
| seen.add(sig) |
| cands.append(s) |
| first = lambda s: next(m["id"] for m in s["moves"] if m["good"]) |
| out = X._sample(cands, n, rng, by=first) |
| rng.shuffle(out) |
| return out |
|
|
|
|
| |
| Q_TEMPLATES = ("{G}: {S} {E}. {ASK}",) * 5 + ("{G}. Effect: {S} {E}. {ASK}",) |
|
|
|
|
| def render_q(sit: dict, rng: random.Random, i: int) -> dict: |
| qs, ts = {}, {} |
| for m in sit["moves"]: |
| tpl = rng.choice(Q_TEMPLATES) |
| text = tpl.format(G=m["gerund"], S=sit["unit"], E=m["effect"], ASK=m["ask"]) |
| if sit["unit"] == "the move": |
| text = f"{m['gerund']}: this move {m['effect']}. {m['ask']}" |
| qs[m["id"]] = noul(text) |
| ts[m["id"]] = noul_target(m["good"]) |
| return _item(f"spatial-game_q-{sit['game']}-{i:04d}", "game_q", sit["game"], sit["status"], qs, ts, pick=True) |
|
|
|
|
| def render_s(sit: dict, rng: random.Random, i: int) -> dict: |
| state = dict(sit["status"]) |
| for m in sit["moves"]: |
| state[m["subj"]] = (sit["unit"] + " " if sit["unit"] != "the move" else "this move ") + m["effect"] |
| items = list(state.items()) |
| head, tail = items[:len(sit["status"])], items[len(sit["status"]):] |
| rng.shuffle(tail) |
| state = dict(head + tail) |
| qs, ts = {}, {} |
| for m in sit["moves"]: |
| qs[m["id"]] = noul(m["ask_s"]) |
| ts[m["id"]] = noul_target(m["good"]) |
| good = [m for m in sit["moves"] if m["good"]] |
| if len(good) == 1: |
| qs["best"] = choice("Which move is the best one here?", {m["id"]: "" for m in sit["moves"]}) |
| ts["best"] = onehot([m["id"] for m in sit["moves"]], good[0]["id"]) |
| return _item(f"spatial-game_s-{sit['game']}-{i:04d}", "game_s", sit["game"], state, qs, ts, pick=True) |
|
|
|
|
| |
| def rule_dino(rng): |
| T = rng.choice([30, 40, 50, 60, 70, 80, 90]) |
| obs = rng.choice(list(DINO_OBS) + ["none"]) |
| dist = rng.choice([rng.randint(3, T - 2), rng.randint(T + 2, T + 60), T - rng.randint(0, 1), T + rng.randint(1, 3)]) |
| rule = (f"Rule: an obstacle on the ground (a cactus) or a low bird closer than {T} px must be jumped over; a high bird " |
| f"closer than {T} px must be ducked under; in every other case the dinosaur keeps running.") |
| kind = DINO_OBS.get(obs) |
| near = obs != "none" and dist < T |
| need = ("duck" if kind == "high" else "jump") if near else "run" |
| state = {"game": "Dino", "next obstacle": obs if obs != "none" else "nothing ahead", |
| "distance to it (px)": dist if obs != "none" else None, "speed (px per tick)": rng.randint(4, 12), |
| "dinosaur": "running"} |
| if obs == "none": |
| del state["distance to it (px)"] |
| ask = {"jump": "Should the dinosaur jump now?", "duck": "Should the dinosaur duck now?", |
| "run": "Should the dinosaur keep running?"} |
| return "Dino", state, rule, {k: v for k, v in ask.items()}, need, "Which action should the dinosaur take now?" |
|
|
|
|
| def rule_breakout(rng): |
| N = rng.choice([10, 15, 20, 30, 40]) |
| off = rng.choice([rng.randint(-60, 60), rng.randint(-N - 4, N + 4)]) |
| p = rng.randint(60, 140) |
| state = {"game": "Breakout", "paddle center x": p, "ball will land at x": p + off, "paddle speed": "fast"} |
| rule = (f"Rule: if the ball will land more than {N} px to the left of the paddle's center, move the paddle left; " |
| f"if more than {N} px to the right, move it right; otherwise leave it where it is.") |
| need = "left" if off < -N else ("right" if off > N else "stay") |
| ask = {"left": "Should the paddle move left?", "right": "Should the paddle move right?", |
| "stay": "Should the paddle stay where it is?"} |
| return "Breakout", state, rule, ask, need, "What should the paddle do?" |
|
|
|
|
| def rule_mole(rng): |
| golden = rng.random() < 0.5 |
| if golden: |
| rule = ("Rule: hit a hole that shows a mole or a golden mole; never hit a bomb or an empty hole; " |
| "skip any hole whose occupant is about to hide.") |
| kinds = ["mole", "bomb", "empty", "golden mole", "mole about to hide"] |
| else: |
| rule = ("Rule: hit a hole only if it shows a mole; never hit a bomb; ignore empty holes. " |
| "A mole that is about to hide cannot be reached in time, so do not swing at it.") |
| kinds = ["mole", "bomb", "empty", "mole about to hide"] |
| kind = rng.choice(kinds) |
| state = {"game": "Whac-A-Mole", "hole under the hammer": rng.choice(HOLES), "it shows": kind, |
| "score": rng.randint(0, 60)} |
| need = "hit" if kind in ("mole", "golden mole") else "wait" |
| ask = {"hit": "Should the player hit this hole?", "wait": "Should the player hold back and not swing?"} |
| return "Whac-A-Mole", state, rule, ask, need, "Hit the hole or hold back?" |
|
|
|
|
| def rule_pacman(rng): |
| N = rng.choice([2, 3, 4, 5]) |
| gd = rng.choice([rng.randint(1, N - 1) if N > 1 else 1, rng.randint(N, N + 4), N, N + 1]) |
| nd = rng.randint(1, 6) |
| rule = (f"Rule: if a ghost is within {N} cells, retreat from it; otherwise move toward the nearest dot; if there is " |
| f"no dot in sight, wander.") |
| has_dot = rng.random() < 0.8 |
| state = {"game": "Pac-Man", "nearest ghost (cells away)": gd, "nearest dot (cells away)": nd if has_dot else "none in sight", |
| "lives": rng.randint(1, 3)} |
| need = "retreat" if gd <= N else ("chase" if has_dot else "wander") |
| ask = {"retreat": "Should Pac-Man retreat from the ghost?", "chase": "Should Pac-Man move toward the nearest dot?", |
| "wander": "Should Pac-Man wander?"} |
| return "Pac-Man", state, rule, ask, need, "What should Pac-Man do?" |
|
|
|
|
| RULE_GEN = {"Dino": rule_dino, "Breakout": rule_breakout, "Whac-A-Mole": rule_mole, "Pac-Man": rule_pacman} |
|
|
|
|
| def rule_items(game: str, n: int, seed: int) -> list: |
| rng = random.Random(f"{seed}:rule:{game}") |
| cands, seen = [], set() |
| while len(cands) < 6 * n: |
| g, state, rule, ask, need, cq = RULE_GEN[game](rng) |
| sig = json.dumps([state, rule]) |
| if sig in seen: |
| continue |
| seen.add(sig) |
| cands.append((g, state, rule, ask, need, cq)) |
| picked = X._sample(cands, n, rng, by=lambda c: c[4]) |
| out = [] |
| for i, (g, state, rule, ask, need, cq) in enumerate(picked): |
| qs = {k: noul(f"{rule} {v}") for k, v in ask.items()} |
| ts = {k: noul_target(k == need) for k in ask} |
| qs["action"] = choice(f"{rule} {cq}", {k: "" for k in ask}) |
| ts["action"] = onehot(list(ask), need) |
| out.append(_item(f"spatial-game_rule-{g}-{i:04d}", "game_rule", g, state, qs, ts, pick=True)) |
| return out |
|
|
|
|
| |
| OBJECTS = [("robot", "charging dock"), ("drone", "landing pad"), ("rover", "sample site"), ("cursor", "button"), |
| ("player", "exit"), ("truck", "warehouse"), ("ship", "harbor"), ("hiker", "cabin")] |
| THINGS = ["lamp", "tree", "well", "kiosk", "bench", "tower", "gate", "flag", "crate", "sensor"] |
|
|
|
|
| def _axes(rng): |
| up = rng.random() < 0.5 |
| return up, ("x grows to the right and y grows upward" if up else "x grows to the right and y grows downward") |
|
|
|
|
| def coord_item(kind: str, rng: random.Random, want: bool | None = None, i: int = 0): |
| up, axes = _axes(rng) |
| a, b, c = rng.sample(THINGS, 3) |
| R = lambda: (rng.randint(-9, 9), rng.randint(-9, 9)) |
| state = {"coordinates": axes} |
| qs, ts = {}, {} |
| if kind == "side": |
| (ax, ay), (bx, by) = R(), R() |
| rel = rng.choice(["left of", "right of", "above", "below"]) |
| while (rel in ("left of", "right of") and ax == bx) or (rel in ("above", "below") and ay == by): |
| (ax, ay), (bx, by) = R(), R() |
| truth = {"left of": ax < bx, "right of": ax > bx, |
| "above": (ay > by) if up else (ay < by), "below": (ay < by) if up else (ay > by)}[rel] |
| if want is not None and truth != want: |
| return None |
| state.update({a: [ax, ay], b: [bx, by]}) |
| qs["q"] = noul(f"Is the {a} {rel} the {b}?") |
| ts["q"] = noul_target(truth) |
| elif kind == "nearer": |
| metric = rng.choice(["Manhattan", "Euclidean"]) |
| p, q1, q2 = R(), R(), R() |
| d = (lambda u, v: abs(u[0] - v[0]) + abs(u[1] - v[1])) if metric == "Manhattan" else \ |
| (lambda u, v: (u[0] - v[0]) ** 2 + (u[1] - v[1]) ** 2) |
| if d(p, q1) == d(p, q2): |
| return None |
| state.update({a: list(p), b: list(q1), c: list(q2), "distance": metric}) |
| qs["q"] = choice(f"Which object is nearer to the {a}, measured by {metric} distance?", {b: "", c: ""}) |
| ts["q"] = onehot([b, c], b if d(p, q1) < d(p, q2) else c) |
| elif kind == "inside": |
| x0, y0 = rng.randint(-8, 2), rng.randint(-8, 2) |
| x1, y1 = x0 + rng.randint(2, 8), y0 + rng.randint(2, 8) |
| pt = R() |
| truth = x0 <= pt[0] <= x1 and y0 <= pt[1] <= y1 |
| if want is not None and truth != want: |
| return None |
| state.update({"rectangle": {"x from": x0, "x to": x1, "y from": y0, "y to": y1}, a: list(pt)}) |
| qs["q"] = noul(f"Is the {a} inside the rectangle (borders included)?") |
| ts["q"] = noul_target(truth) |
| elif kind == "reduce": |
| o, t = OBJECTS[rng.randrange(len(OBJECTS))] |
| p, q1 = R(), R() |
| dx, dy = q1[0] - p[0], q1[1] - p[1] |
| mv = rng.choice(["left", "right", "up", "down"]) |
| step = {"left": (-1, 0), "right": (1, 0), "up": (0, 1 if up else -1), "down": (0, -1 if up else 1)}[mv] |
| if dx == 0 and dy == 0: |
| return None |
| d0 = (dx * dx + dy * dy) |
| d1 = ((dx - step[0]) ** 2 + (dy - step[1]) ** 2) |
| if d0 == d1: |
| return None |
| truth = d1 < d0 |
| if want is not None and truth != want: |
| return None |
| state.update({o: list(p), t: list(q1)}) |
| qs["q"] = noul(f"Does moving the {o} one step {mv} bring it closer to the {t} (straight-line distance)?") |
| ts["q"] = noul_target(truth) |
| elif kind == "best_dir": |
| o, t = OBJECTS[rng.randrange(len(OBJECTS))] |
| p, q1 = R(), R() |
| dx, dy = q1[0] - p[0], q1[1] - p[1] |
| if abs(abs(dx) - abs(dy)) < 2: |
| return None |
| if abs(dx) > abs(dy): |
| best = "right" if dx > 0 else "left" |
| else: |
| best = ("up" if dy > 0 else "down") if up else ("down" if dy > 0 else "up") |
| state.update({o: list(p), t: list(q1)}) |
| qs["q"] = choice(f"The {o} takes one step toward the {t}. Which step reduces the straight-line distance the most?", |
| {"up": "", "down": "", "left": "", "right": ""}) |
| ts["q"] = onehot(["up", "down", "left", "right"], best) |
| elif kind == "within": |
| metric = rng.choice(["Manhattan", "Euclidean"]) |
| p, q1 = R(), R() |
| dist = abs(p[0] - q1[0]) + abs(p[1] - q1[1]) if metric == "Manhattan" else \ |
| ((p[0] - q1[0]) ** 2 + (p[1] - q1[1]) ** 2) ** 0.5 |
| thr = max(1, int(dist) + rng.choice([-3, -2, -1, 1, 2, 3])) |
| truth = dist <= thr |
| if want is not None and truth != want: |
| return None |
| state.update({a: list(p), b: list(q1)}) |
| qs["q"] = noul(f"Is the {b} within {thr} units of the {a} ({metric} distance)?") |
| ts["q"] = noul_target(truth) |
| return _item(f"spatial-spatial_coord-{kind}-{i:04d}", "spatial_coord", "coord", state, qs, ts, |
| source=f"spatial:coord:{kind}") |
|
|
|
|
| COORD_KINDS = ("side", "nearer", "inside", "reduce", "best_dir", "within") |
|
|
|
|
| def coord_items(n: int, seed: int) -> list: |
| rng = random.Random(f"{seed}:coord") |
| out = [] |
| per = n // len(COORD_KINDS) |
| for kind in COORD_KINDS: |
| k = 0 |
| while k < per + (n - per * len(COORD_KINDS) if kind == COORD_KINDS[0] else 0): |
| want = (k % 2 == 0) if kind not in ("nearer", "best_dir") else None |
| it = coord_item(kind, rng, want, k) |
| if it: |
| out.append(it) |
| k += 1 |
| return out |
|
|
|
|
| |
| SYMS = [("K", "key"), ("D", "door"), ("T", "tree"), ("W", "water"), ("R", "rock"), ("C", "chest"), ("G", "guard"), |
| ("S", "start")] |
|
|
|
|
| def _grid(rng): |
| n = rng.randint(5, 9) |
| m = rng.randint(5, 9) |
| syms = rng.sample(SYMS, rng.randint(3, 5)) |
| grid = [["." for _ in range(m)] for _ in range(n)] |
| for s, _ in syms: |
| for _ in range(rng.randint(1, 4) if s not in ("K", "D", "S", "C") else 1): |
| r, c = rng.randrange(n), rng.randrange(m) |
| if grid[r][c] == ".": |
| grid[r][c] = s |
| return n, m, syms, grid |
|
|
|
|
| def _gstate(n, m, syms, grid): |
| rows = "\n".join(" ".join(r) for r in grid) |
| legend = ", ".join(f"{s} = {name}" for s, name in syms) + ", . = empty floor" |
| return (f"Grid with {n} rows and {m} columns (row 1 is the top row, column 1 is the leftmost column):\n{rows}\n" |
| f"Legend: {legend}.") |
|
|
|
|
| def grid_item(kind: str, rng: random.Random, want: bool | None, i: int): |
| n, m, syms, grid = _grid(rng) |
| name = dict(syms) |
| cells = {s: [(r, c) for r in range(n) for c in range(m) if grid[r][c] == s] for s, _ in syms} |
| single = [s for s, _ in syms if len(cells[s]) == 1] |
| qs, ts = {}, {} |
| if kind == "relative": |
| if len(single) < 2: |
| return None |
| x, y = rng.sample(single, 2) |
| (rx, cx), (ry, cy) = cells[x][0], cells[y][0] |
| rel = rng.choice(["above", "below", "left of", "right of"]) |
| if (rel in ("above", "below") and rx == ry) or (rel in ("left of", "right of") and cx == cy): |
| return None |
| truth = {"above": rx < ry, "below": rx > ry, "left of": cx < cy, "right of": cx > cy}[rel] |
| if want is not None and truth != want: |
| return None |
| qs["q"] = noul(f"Is the {name[x]} ({x}) {rel} the {name[y]} ({y}) on the grid?") |
| ts["q"] = noul_target(truth) |
| elif kind == "free": |
| r, c = rng.randrange(n), rng.randrange(m) |
| truth = grid[r][c] == "." |
| if want is not None and truth != want: |
| return None |
| qs["q"] = noul(f"Is the cell in row {r + 1}, column {c + 1} empty floor?") |
| ts["q"] = noul_target(truth) |
| elif kind == "count_row" or kind == "count_col": |
| s = rng.choice(syms)[0] |
| if kind == "count_row": |
| idx = rng.randrange(n) |
| cnt = sum(1 for c in range(m) if grid[idx][c] == s) |
| where = f"row {idx + 1}" |
| else: |
| idx = rng.randrange(m) |
| cnt = sum(1 for r in range(n) if grid[r][idx] == s) |
| where = f"column {idx + 1}" |
| if cnt > 4: |
| return None |
| if kind == "count_row": |
| qs["q"] = score_q(f"How many {name[s]} cells ({s}) are in {where}?", ["0", "1", "2", "3", "4"]) |
| ts["q"] = {str(j): float(j == cnt) for j in range(5)} |
| else: |
| qs["q"] = choice(f"How many {name[s]} cells ({s}) are in {where}?", {str(j): "" for j in range(5)}) |
| ts["q"] = onehot([str(j) for j in range(5)], str(cnt)) |
| elif kind == "adjacent": |
| pairs = [(s, t) for s in single for t in single if s < t] |
| if not pairs: |
| return None |
| x, y = rng.choice(pairs) |
| (rx, cx), (ry, cy) = cells[x][0], cells[y][0] |
| truth = abs(rx - ry) + abs(cx - cy) == 1 |
| if want is not None and truth != want: |
| return None |
| qs["q"] = noul(f"Is the {name[x]} ({x}) directly next to the {name[y]} ({y}) (sharing a side, no diagonals)?") |
| ts["q"] = noul_target(truth) |
| return _item(f"spatial-spatial_grid-{kind}-{i:04d}", "spatial_grid", "grid", _gstate(n, m, syms, grid), qs, ts, |
| source=f"spatial:grid:{kind}") |
|
|
|
|
| def _adjacent_forced(rng, i): |
| """Adjacent pairs are rare at random: place two single symbols next to each other on purpose half the time.""" |
| n, m, syms, grid = _grid(rng) |
| return n, m, syms, grid |
|
|
|
|
| GRID_KINDS = ("relative", "free", "count_row", "count_col", "adjacent") |
|
|
|
|
| def grid_items(n: int, seed: int) -> list: |
| rng = random.Random(f"{seed}:grid") |
| out = [] |
| per = n // len(GRID_KINDS) |
| for kind in GRID_KINDS: |
| k, tries = 0, 0 |
| counts = {} |
| while k < per and tries < 200000: |
| tries += 1 |
| want = (k % 2 == 0) if kind in ("relative", "free", "adjacent") else None |
| it = grid_item(kind, rng, want, k) |
| if not it: |
| continue |
| if kind.startswith("count"): |
| gold = max(it["targets"]["q"], key=it["targets"]["q"].get) |
| counts[gold] = counts.get(gold, 0) + 1 |
| if counts[gold] > 0.34 * per + 2: |
| counts[gold] -= 1 |
| continue |
| out.append(it) |
| k += 1 |
| return out |
|
|
|
|
| |
| def build(seed: int = 0, sizes: dict | None = None) -> tuple[list, dict]: |
| scale = {**SIZES, **(sizes or {})} |
| f = lambda skill: scale[skill] / SIZES[skill] |
| items = [] |
| sits_n = {g: max(2, round(n * f("game_q"))) for g, n in GAME_N.items()} |
| rng = random.Random(f"{seed}:render") |
| for g in SEEN + UNSEEN: |
| sits = make_situations(g, sits_n[g], seed) |
| items += [render_q(s, random.Random(f"{seed}:q:{g}:{i}"), i) for i, s in enumerate(sits)] |
| items += [render_s(s, random.Random(f"{seed}:s:{g}:{i}"), i) for i, s in enumerate(sits)] |
| for g, n in RULE_N.items(): |
| items += rule_items(g, max(2, round(n * f("game_rule"))), seed) |
| items += coord_items(max(6, round(SIZES["spatial_coord"] * f("spatial_coord"))), seed) |
| items += grid_items(max(5, round(SIZES["spatial_grid"] * f("spatial_grid"))), seed) |
| del rng |
| ids = set() |
| for x in items: |
| assert x["id"] not in ids, x["id"] |
| ids.add(x["id"]) |
| info = {"version": VERSION, "seed": seed, |
| "counts": {s: sum(x["skill"] == s for x in items) for s in SKILLS}, |
| "questions": {s: sum(len(x["questions"]) for x in items if x["skill"] == s) for s in SKILLS}, |
| "by_split": {f"{s}/{sp}": sum(x["skill"] == s and x["split"] == sp for x in items) |
| for s in SKILLS for sp in ("seen_game", "unseen_game", "generic") |
| if any(x["skill"] == s and x["split"] == sp for x in items)}, |
| "by_source": {}} |
| for x in items: |
| info["by_source"][x["source"]] = info["by_source"].get(x["source"], 0) + 1 |
| info["by_source"] = dict(sorted(info["by_source"].items())) |
| noul_true = [t["true"] for x in items for k, t in x["targets"].items() if x["questions"][k]["type"] == "noul"] |
| info["noul_gold_true_rate"] = round(sum(noul_true) / len(noul_true), 4) |
| return items, info |
|
|
|
|
| def state_hashes(items: list) -> list: |
| return sorted({hashlib.sha1(x["state"].encode()).hexdigest() for x in items}) |
|
|
|
|
| def write(items: list, info: dict, outdir: str = ".") -> list: |
| import os |
|
|
| p = os.path.join(outdir, "jevspatial_v1_items.json.gz") |
| with gzip.open(p, "wt") as fh: |
| json.dump(items, fh, ensure_ascii=False) |
| return [p] |
|
|
|
|
| if __name__ == "__main__": |
| import argparse |
|
|
| ap = argparse.ArgumentParser(description="build JevSpatial v1 items") |
| ap.add_argument("--seed", type=int, default=0) |
| ap.add_argument("--out", default=".") |
| a = ap.parse_args() |
| its, inf = build(a.seed) |
| print(json.dumps(inf, indent=1)) |
| print(write(its, inf, a.out)) |
|
|
