| import ast |
| import importlib |
| import json |
| import os |
| import re |
| from pathlib import Path |
|
|
| import numpy as np |
| from minatar import Environment |
|
|
| TENSOR_SHAPES = { |
| "W1": (600, 32), |
| "b1": (32,), |
| "W2": (32, 32), |
| "b2": (32,), |
| "W3": (32, 6), |
| "b3": (6,), |
| } |
| ORIGINAL_CHANNEL_GROUPS = { |
| "asterix": ((0,), (1,), (3,), (), (2,), ()), |
| "breakout": ((0,), (), (3,), (1,), (2,), ()), |
| "freeway": ((0,), (1,), (), (), (2, 3, 4, 5, 6), ()), |
| "seaquest": ((0, 1), (5, 6, 4), (5, 6, 9), (2,), (3, 1), (7, 8)), |
| "space_invaders": ((0,), (1, 5), (1,), (4,), (2, 3), ()), |
| } |
| ORIGINAL_SCORE_CAPS = { |
| "asterix": 1_000.0, |
| "breakout": 1_000.0, |
| "freeway": 100.0, |
| "seaquest": 1_000.0, |
| "space_invaders": 1_000.0, |
| } |
| EDITS_BLOCK = re.compile(r"```edits\s*\n(.*?)```", re.DOTALL | re.IGNORECASE) |
|
|
|
|
| def assistant_answer(trajectory: dict) -> str: |
| for step in reversed(trajectory.get("steps") or []): |
| for message in reversed(step.get("messages") or []): |
| if message.get("role") != "assistant": |
| continue |
| content = message.get("content") |
| if isinstance(content, str): |
| return content |
| if isinstance(content, list): |
| texts = [item.get("text", "") for item in content if isinstance(item, dict)] |
| return "\n".join(texts) |
| return "" |
|
|
|
|
| def _slice(node: ast.expr) -> slice | int: |
| if isinstance(node, ast.Slice): |
| return slice( |
| ast.literal_eval(node.lower) if node.lower is not None else None, |
| ast.literal_eval(node.upper) if node.upper is not None else None, |
| ast.literal_eval(node.step) if node.step is not None else None, |
| ) |
| return int(ast.literal_eval(node)) |
|
|
|
|
| def _target(node: ast.expr, tensors: dict[str, np.ndarray]) -> tuple[np.ndarray, object]: |
| if not isinstance(node, ast.Subscript) or not isinstance(node.value, ast.Name): |
| raise ValueError("edit target must index a named tensor") |
| if node.value.id not in tensors: |
| raise ValueError(f"unknown tensor {node.value.id!r}") |
| index = node.slice |
| key = ( |
| tuple(_slice(item) for item in index.elts) if isinstance(index, ast.Tuple) else _slice(index) |
| ) |
| return tensors[node.value.id], key |
|
|
|
|
| def apply_edits(answer: str) -> tuple[dict[str, np.ndarray], int]: |
| matches = EDITS_BLOCK.findall(answer) |
| if not matches: |
| raise ValueError("answer has no edits block") |
| tree = ast.parse(matches[-1], mode="exec") |
| tensors = {name: np.zeros(shape, dtype=np.float32) for name, shape in TENSOR_SHAPES.items()} |
| applied = 0 |
| for statement in tree.body: |
| if isinstance(statement, ast.Assign) and len(statement.targets) == 1: |
| tensor, key = _target(statement.targets[0], tensors) |
| tensor[key] = ast.literal_eval(statement.value) |
| elif isinstance(statement, ast.AugAssign): |
| tensor, key = _target(statement.target, tensors) |
| value = ast.literal_eval(statement.value) |
| if isinstance(statement.op, ast.Mult): |
| tensor[key] *= value |
| elif isinstance(statement.op, ast.Add): |
| tensor[key] += value |
| elif isinstance(statement.op, ast.Sub): |
| tensor[key] -= value |
| else: |
| raise ValueError("only *=, +=, and -= augmented edits are allowed") |
| else: |
| raise ValueError("edits may contain only assignments") |
| applied += 1 |
| values = np.concatenate([tensor.ravel() for tensor in tensors.values()]) |
| if not np.all(np.isfinite(values)) or np.max(np.abs(values), initial=0.0) > 1e6: |
| raise ValueError("weights must be finite and have absolute value at most 1e6") |
| return tensors, applied |
|
|
|
|
| def synth_environment_class(game: str) -> type: |
| module = importlib.import_module(f"minatar_synth.games.{game}") |
| candidates = [ |
| value |
| for name, value in vars(module).items() |
| if name.endswith("Environment") |
| and isinstance(value, type) |
| and value.__module__ == module.__name__ |
| ] |
| if len(candidates) != 1: |
| raise ValueError(f"expected one environment class for {game}, found {len(candidates)}") |
| return candidates[0] |
|
|
|
|
| def make_environment(game: str, source: str) -> object: |
| if source == "original": |
| return Environment(game, sticky_action_prob=0.1, difficulty_ramping=False) |
| return synth_environment_class(game)(sticky_action_prob=0.1) |
|
|
|
|
| def observation(game: str, source: str, state: np.ndarray) -> np.ndarray: |
| if source == "synth": |
| if state.shape != (10, 10, 6): |
| raise ValueError(f"invalid synthetic state shape {state.shape}") |
| return state.astype(np.float32).reshape(600) |
| channels = np.zeros((10, 10, 6), dtype=np.float32) |
| for output_channel, source_channels in enumerate(ORIGINAL_CHANNEL_GROUPS[game]): |
| if source_channels: |
| channels[:, :, output_channel] = np.any(state[:, :, source_channels], axis=2) |
| return channels.reshape(600) |
|
|
|
|
| def logits(weights: dict[str, np.ndarray], state: np.ndarray) -> np.ndarray: |
| hidden1 = np.tanh(state @ weights["W1"] + weights["b1"]) |
| hidden2 = np.tanh(hidden1 @ weights["W2"] + weights["b2"]) |
| return hidden2 @ weights["W3"] + weights["b3"] |
|
|
|
|
| def sample_action(action_logits: np.ndarray, random: np.random.RandomState) -> int: |
| shifted = action_logits.astype(np.float64) - np.max(action_logits) |
| probabilities = np.exp(shifted) |
| probabilities /= probabilities.sum() |
| return int(random.choice(6, p=probabilities)) |
|
|
|
|
| def score_cap(game: str, source: str) -> float: |
| if source == "original": |
| return ORIGINAL_SCORE_CAPS[game] |
| return float(synth_environment_class(game).score_cap) |
|
|
|
|
| def evaluate( |
| game: str, source: str, weights: dict[str, np.ndarray], episodes: int |
| ) -> tuple[float, float]: |
| scores = [] |
| lengths = [] |
| for episode in range(episodes): |
| environment = make_environment(game, source) |
| environment.seed(1729 + episode) |
| action_random = np.random.RandomState(7919 + episode) |
| environment.reset() |
| score = 0.0 |
| for step in range(10_000): |
| action = sample_action( |
| logits(weights, observation(game, source, environment.state())), action_random |
| ) |
| reward, terminal = environment.act(action) |
| score += float(reward) |
| if terminal: |
| break |
| scores.append(score) |
| lengths.append(step + 1) |
| return float(np.mean(scores)), float(np.mean(lengths)) |
|
|
|
|
| def grade_answer( |
| game: str, source: str, answer: str, episodes: int |
| ) -> tuple[float, dict[str, object]]: |
| metadata: dict[str, object] = { |
| "game": game, |
| "source": source, |
| "episodes": episodes, |
| "parse_success": 0.0, |
| } |
| try: |
| weights, edit_count = apply_edits(answer) |
| raw_score, mean_length = evaluate(game, source, weights, episodes) |
| cap = score_cap(game, source) |
| normalized_score = min(max(raw_score, 0.0), cap) / cap |
| metadata.update( |
| { |
| "parse_success": 1.0, |
| "raw_score": raw_score, |
| "score_cap": cap, |
| "mean_episode_length": mean_length, |
| "edit_count": edit_count, |
| "nonzero_weights": sum(int(np.count_nonzero(value)) for value in weights.values()), |
| } |
| ) |
| return normalized_score, metadata |
| except (ImportError, IndexError, KeyError, SyntaxError, TypeError, ValueError) as error: |
| metadata["error"] = str(error) |
| return 0.0, metadata |
|
|
|
|
| def main() -> None: |
| game = os.environ["WEIGHT_SPACE_GAME"] |
| source = os.environ["WEIGHT_SPACE_SOURCE"] |
| episodes = int(os.environ.get("WEIGHT_SPACE_EPISODES", "1000")) |
| trajectory = json.loads(Path("/logs/trajectory.json").read_text()) |
| normalized_score, metadata = grade_answer(game, source, assistant_answer(trajectory), episodes) |
| reward_path = Path("/logs/verifier/reward.json") |
| reward_path.parent.mkdir(parents=True, exist_ok=True) |
| reward_path.write_text(json.dumps({"normalized_score": normalized_score, **metadata})) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
