|
|
|
|
|
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() |
|
|
