Add multithreading to synthetic dataset generation

generate_hf_dataset.py

@@ -29,8 +29,10 @@ from __future__ import annotations
 import argparse
 import json
 import logging
+import os
 import subprocess
 import sys
+from concurrent.futures import ProcessPoolExecutor, as_completed
 from datetime import UTC, datetime
 from pathlib import Path
 from random import Random
@@ -42,6 +44,7 @@ from multilingual_gsm_symbolic import available_languages, load_data, load_repla
 
 DEFAULT_SEED = 42
 DEFAULT_N = 20
+DEFAULT_WORKERS = os.cpu_count() or 1
 HF_DATA_DIR = Path(__file__).resolve().parent / "data"
 GENERATION_LOG = HF_DATA_DIR / "generation_log.json"
 
@@ -74,36 +77,48 @@ def build_original_rows(lang: str) -> list[dict]:
     ]
 
 
-def build_synthetic_rows(lang: str, n: int, rng: Random) -> list[dict]:
+def _synthetic_rows_for_template(lang: str, n: int, replacements: dict, template) -> list[dict]:
+    rng = Random(template.id_orig)
+    questions = template.generate_questions(n=n, replacements=replacements, rng=rng)
+    return [
+        {
+            "question": q.question,
+            "answer": q.answer,
+            "target": _extract_target(q.answer),
+            "language": lang,
+            "source_id": q.id_orig,
+        }
+        for q in questions
+    ]
+
+
+def build_synthetic_rows(lang: str, n: int, workers: int) -> list[dict]:
     replacements = load_replacements(lang)
     templates = load_data(lang)
-    rows = []
-    for i, template in enumerate(templates, 1):
-        questions = template.generate_questions(n=n, replacements=replacements, rng=rng)
-        for q in questions:
-            rows.append(
-                {
-                    "question": q.question,
-                    "answer": q.answer,
-                    "target": _extract_target(q.answer),
-                    "language": lang,
-                    "source_id": q.id_orig,
-                }
-            )
-        log.info(f"[{lang}] {i}/{len(templates)} templates done (id_shuffled={template.id_shuffled})")
-    return rows
-
-
-def generate(lang: str, seed: int, n: int) -> None:
+    results: list[list[dict] | None] = [None] * len(templates)
+
+    with ProcessPoolExecutor(max_workers=workers) as executor:
+        futures = {
+            executor.submit(_synthetic_rows_for_template, lang, n, replacements, template): (i, template)
+            for i, template in enumerate(templates)
+        }
+        for done, future in enumerate(as_completed(futures), 1):
+            i, template = futures[future]
+            results[i] = future.result()
+            log.info(f"[{lang}] {done}/{len(templates)} templates done (id_shuffled={template.id_shuffled})")
+
+    return [row for template_rows in results if template_rows is not None for row in template_rows]
+
+
+def generate(lang: str, seed: int, n: int, workers: int) -> None:
     out_dir = HF_DATA_DIR / lang
     out_dir.mkdir(parents=True, exist_ok=True)
 
     log.info(f"[{lang}] Building original split...")
     original_rows = build_original_rows(lang)
 
-    log.info(f"[{lang}] Building synthetic split (n={n}, seed={seed})...")
-    rng = Random(seed)
-    synthetic_rows = build_synthetic_rows(lang, n=n, rng=rng)
+    log.info(f"[{lang}] Building synthetic split (n={n}, seed=id_orig, workers={workers})...")
+    synthetic_rows = build_synthetic_rows(lang, n=n, workers=workers)
 
     dataset = DatasetDict(
         {
@@ -123,6 +138,8 @@ def generate(lang: str, seed: int, n: int) -> None:
         existing = json.loads(GENERATION_LOG.read_text(encoding="utf-8"))
     existing[lang] = {
         "seed": seed,
+        "synthetic_template_seed": "id_orig",
+        "workers": workers,
         "n_synthetic_per_template": n,
         "commit": _git_commit(),
         "package_version": multilingual_gsm_symbolic.__version__,
@@ -141,8 +158,18 @@ def main() -> None:
     parser.add_argument(
         "--n", type=int, default=DEFAULT_N, help=f"Synthetic questions per template (default: {DEFAULT_N})"
     )
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=DEFAULT_WORKERS,
+        help=f"Worker processes for synthetic generation (default: {DEFAULT_WORKERS})",
+    )
     args = parser.parse_args()
 
+    if args.workers < 1:
+        print("--workers must be at least 1", file=sys.stderr)
+        sys.exit(1)
+
     available = available_languages()
     langs = list(available) if args.lang is None else [args.lang]
 
@@ -150,7 +177,7 @@ def main() -> None:
         if lang not in available:
             print(f"Unknown language '{lang}'. Available: {', '.join(available)}", file=sys.stderr)
             sys.exit(1)
-        generate(lang=lang, seed=args.seed, n=args.n)
+        generate(lang=lang, seed=args.seed, n=args.n, workers=args.workers)
 
 
 if __name__ == "__main__":