| |
|
|
| import numpy as np |
| import sys |
| from pathlib import Path |
| import subprocess |
| import os |
| import json |
| from typing import Literal |
| import logging |
|
|
| logging.basicConfig(level=logging.INFO) |
|
|
|
|
| GameType = Literal["disc", "recon"] |
|
|
| |
| disc_hparams_header = ( |
| ["n_attrs", "n_vals", "n_distractors", "n_examples", "vocab_size", "msg_len"] |
| ) |
| disc_variant_arr = [ |
| [ 4, 4, 3, 10000, 10, 10], |
| [ 6, 6, 3, 10000, 10, 10], |
| [ 6, 6, 9, 10000, 10, 10], |
| [ 8, 8, 3, 10000, 10, 10], |
| ] |
| |
| disc_variants = [ |
| dict(list(zip(disc_hparams_header, row)) + [("seed", s)]) |
| for s in range(0,3) |
| for row in disc_variant_arr |
| ] |
|
|
| |
| recon_hparams_header = ( |
| ["n_attrs", "n_vals", "n_examples", "vocab_size", "msg_len"] |
| ) |
| recon_variant_arr = [ |
| [ 4, 4, 10000, 10, 10], |
| [ 6, 6, 10000, 10, 10], |
| [ 8, 8, 10000, 10, 10], |
| ] |
| |
| recon_variants = [dict(zip(recon_hparams_header, row)) for row in recon_variant_arr] |
|
|
|
|
| def generate_data( |
| *, |
| game_type: GameType, |
| n_attrs: int, |
| n_vals: int, |
| n_distractors: int | None = None, |
| n_examples: int, |
| **kwargs, |
| ) -> Path: |
| rng = np.random.default_rng(0) |
|
|
| n_items = n_vals**n_attrs |
| out_dir = Path("input-data") |
| out_dir.mkdir(exist_ok=True, parents=True) |
| match game_type: |
| case "disc": |
| assert n_distractors is not None |
| fn = f"{n_attrs}-attr_{n_vals}-val_{n_distractors}-dist.txt" |
| case "recon": |
| fn = f"{n_attrs}-attr_{n_vals}-val.txt" |
| out_path = out_dir / fn |
| if out_path.exists(): |
| logging.info(f"{out_path} already exists; skipping data generation.") |
| else: |
| |
| with out_path.open("w") as fo: |
| match game_type: |
| case "disc": |
| assert n_distractors is not None |
|
|
| def write_example() -> None: |
| raw = rng.choice(n_items, n_distractors + 1, replace=False) |
| label = rng.integers(n_distractors + 1) |
| sample = np.empty((n_distractors + 1, n_attrs), dtype=np.int64) |
| for j in range(n_attrs): |
| sample[:, j] = raw // (n_vals**j) % n_vals |
| fo.write( |
| " . ".join(" ".join(str(x) for x in row) for row in sample) |
| ) |
| fo.write(" . ") |
| fo.write(str(label)) |
| fo.write("\n") |
|
|
| case "recon": |
|
|
| def write_example() -> None: |
| raw = rng.choice(n_items) |
| sample = raw // (n_vals ** np.arange(n_attrs)) % n_vals |
| fo.write(" ".join(str(x) for x in sample)) |
| fo.write("\n") |
|
|
| for i in range(n_examples): |
| write_example() |
| return out_path |
|
|
|
|
| def run_environment(game_type: GameType, cfg: dict, data_path: Path) -> Path: |
| out_dir = Path("output-data") |
| out_dir.mkdir(parents=True, exist_ok=True) |
| match game_type: |
| case "disc": |
| fn_parts = [ |
| cfg["n_attrs"] + "-attr", |
| cfg["n_vals"] + "-val", |
| cfg["n_distractors"] + "-dist", |
| cfg["seed"] + "-seed", |
| |
| |
| ] |
| case "recon": |
| fn_parts = [ |
| cfg["n_attrs"] + "-attr", |
| cfg["n_vals"] + "-val", |
| cfg["vocab_size"] + "-vocab", |
| cfg["msg_len"] + "-len", |
| ] |
| out_file = out_dir / ("_".join(fn_parts) + ".out") |
| if out_file.exists(): |
| logging.info(f"{out_file} already exists; skipping running environment.") |
| else: |
| |
| cmd = [ |
| "python", |
| "-m", "egg.zoo.basic_games.play", |
| "--mode", "gs", |
| "--game_type", "discri" if game_type == "disc" else "recon", |
| "--train_data", str(data_path), |
| "--validation_data", str(data_path), |
| "--n_attributes", cfg["n_attrs"], |
| "--n_values", cfg["n_vals"], |
| "--n_epochs", "100", |
| "--batch_size", "1024", |
| "--validation_batch_size", "1024", |
| "--max_len", cfg["msg_len"], |
| "--vocab_size", cfg["vocab_size"], |
| "--random_seed", cfg.get("seed", 0), |
| "--sender_hidden", "256", |
| "--receiver_hidden", "512", |
| "--sender_embedding", "32", |
| "--receiver_embedding", "32", |
| "--receiver_cell", "gru", |
| "--sender_cell", "gru", |
| "--lr", "0.001", |
| "--print_validation_events", |
| ] |
| |
| env = os.environ.copy() |
| python_path = env.get("PYTHONPATH", "") + ":repo" |
| env["PYTHONPATH"] = python_path.lstrip(":") |
| with out_file.open("w") as fo: |
| subprocess.run(cmd, stdout=fo, env=env) |
| return out_file |
|
|
|
|
| def process_output(raw_out_path: Path) -> None: |
| out_path = Path("../data") / raw_out_path.stem / "corpus.jsonl" |
| out_path.parent.mkdir(parents=True, exist_ok=True) |
| if out_path.exists(): |
| logging.info(f"{out_path} already exists; skipping output processing.") |
| else: |
| with raw_out_path.open() as fo: |
| while "MESSAGES\n" != (line := fo.readline()): |
| if line == "": |
| raise ValueError("Could not find MESSAGES block in output file.") |
| messages = fo.readline() |
| with out_path.open("w") as fo: |
| messages = json.loads(messages) |
| messages = np.argmax(messages, -1).tolist() |
| for m in messages: |
| fo.write(json.dumps(m, separators=(",", ":"))) |
| fo.write("\n") |
|
|
|
|
| def main() -> None: |
| cwd_parent = os.getcwd().split("/")[-2] |
| logging.info( |
| f'Using working directory parent "{cwd_parent}" to detect what config to run...' |
| ) |
| match cwd_parent: |
| case "egg-discrimination": |
| logging.info("Running discrimination...") |
| for cfg in disc_variants: |
| data_path = generate_data(game_type="disc", **cfg) |
| cfg_strs = {k: str(v) for k, v in cfg.items()} |
| out_path = run_environment("disc", cfg_strs, data_path) |
| process_output(out_path) |
| case "egg-reconstruction": |
| logging.info("Running reconstruction...") |
| for cfg in recon_variants: |
| data_path = generate_data(game_type="recon", **cfg) |
| cfg_strs = {k: str(v) for k, v in cfg.items()} |
| out_path = run_environment("recon", cfg_strs, data_path) |
| process_output(out_path) |
| case _: |
| logging.error("No match found.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
