generate_path_dataset.py

#!/usr/bin/env python3
"""Generate Path (minimal planning) JSONL under ``data/``.

Examples (from repo root)::

    python data/generate_path_dataset.py --node-per-stream 10 --out-dir data
    python data/generate_path_dataset.py --node-per-stream 14 --out-dir data

Writes ``path-2-10_train.jsonl`` / ``path-2-10_test.jsonl`` (and 2-14, etc.).
Always regenerate train+test together. Test is generated first, then train.
"""

import argparse
import json
import random
from pathlib import Path


def save_jsonl(data, file):
    with open(file, "w", encoding="utf-8") as f:
        for item in data:
            json.dump(item, f)
            f.write("\n")


def path_stringfy(input_list, shuffle=True):
    output_list = []
    for i in range(len(input_list) - 1):
        output_list.append(f"{input_list[i]},{input_list[i + 1]}")
    if shuffle:
        random.shuffle(output_list)
    return "/".join(output_list)


def paths_stringfy(input_lists, shuffle=True):
    output_list = []
    for input_list in input_lists:
        for i in range(len(input_list) - 1):
            output_list.append(f"{input_list[i]},{input_list[i + 1]}")
    if shuffle:
        random.shuffle(output_list)
    return "/".join(output_list)


def convert_to_jsonline(data_list):
    res = []
    for data in data_list:
        answer_str = path_stringfy(data[0], shuffle=False)
        reverse_answer_str = path_stringfy(data[0][::-1], shuffle=False)
        path_str = paths_stringfy(data)
        input_str = path_str + f"-{data[0][0]},{data[0][-1]}"
        res.append({"input": input_str, "output": answer_str, "reversed": reverse_answer_str})
    return res


def generate_streams(num, stream, node_per_stream, cache, progress_interval):
    data = []
    numbers = list(range(node_per_stream * stream))
    while len(data) < num:
        sep_position = random.randint(0, node_per_stream - 1)
        random.shuffle(numbers)
        cache_key = tuple(numbers)
        if cache_key in cache:
            continue
        cache.add(cache_key)

        streams = [numbers[node_per_stream * i : node_per_stream * (i + 1)] for i in range(stream)]
        answer = streams[0]
        for s in streams[1:]:
            s[sep_position] = answer[sep_position]
        data.append(streams)

        if progress_interval > 0 and len(data) % progress_interval == 0:
            print(f"generated {len(data)}/{num}")
    return data


def default_train_name(stream, node_per_stream):
    # e.g. path-2-14_train.jsonl  (Path10 → path-2-10, Path14 → path-2-14)
    return f"path-{stream}-{node_per_stream}_train.jsonl"


def default_test_name(stream, node_per_stream):
    return f"path-{stream}-{node_per_stream}_test.jsonl"


def parse_args():
    parser = argparse.ArgumentParser(description="Generate minimal planning path datasets.")
    parser.add_argument("--stream", type=int, default=2)
    parser.add_argument("--node-per-stream", type=int, default=14)
    parser.add_argument("--num-train", type=int, default=1_000_000)
    parser.add_argument("--num-test", type=int, default=1_000)
    parser.add_argument("--seed", type=int, default=1)
    parser.add_argument("--out-dir", type=str, default=".")
    parser.add_argument("--train-name", type=str, default=None)
    parser.add_argument("--test-name", type=str, default=None)
    parser.add_argument("--progress-interval", type=int, default=10000)
    return parser.parse_args()


def main():
    args = parse_args()
    random.seed(args.seed)
    cache = set()

    out_dir = Path(args.out_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    train_name = args.train_name or default_train_name(args.stream, args.node_per_stream)
    test_name = args.test_name or default_test_name(args.stream, args.node_per_stream)

    print(
        f"Generating minimal planning dataset: stream={args.stream}, "
        f"node_per_stream={args.node_per_stream}, train={args.num_train}, test={args.num_test}"
    )
    # Test first, train last (stable held-out when only train size changes).
    test_streams = generate_streams(
        args.num_test, args.stream, args.node_per_stream, cache, args.progress_interval
    )
    test_path = out_dir / test_name
    save_jsonl(convert_to_jsonline(test_streams), test_path)
    print(f"test  -> {test_path}  ({len(test_streams)} rows)")

    if args.num_train > 0:
        train_streams = generate_streams(
            args.num_train, args.stream, args.node_per_stream, cache, args.progress_interval
        )
        train_path = out_dir / train_name
        save_jsonl(convert_to_jsonline(train_streams), train_path)
        print(f"train -> {train_path}  ({len(train_streams)} rows)")
    else:
        print("train -> skipped (num_train=0)")


if __name__ == "__main__":
    main()