File size: 4,757 Bytes
97ecad4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | #!/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()
|