# /// script # requires-python = ">=3.12" # dependencies = [ # "multilingual-gsm-symbolic", # "datasets>=3.0.0", # ] # # [tool.uv.sources] # multilingual-gsm-symbolic = { path = "..", editable = true } # /// """Generate the HuggingFace dataset splits for one language and write them locally. Produces parquet files and a generation log under ``hf_dataset/data//``. No upload is performed — push to the Hub separately when ready. Usage: uv run hf_dataset/generate_hf_dataset.py --lang eng uv run hf_dataset/generate_hf_dataset.py --lang dan --seed 42 uv run hf_dataset/generate_hf_dataset.py --lang eng --n 20 uv run hf_dataset/generate_hf_dataset.py --lang eng --split test uv run hf_dataset/generate_hf_dataset.py --lang eng --split train Output per language: hf_dataset/data//test_original-00000-of-00001.parquet hf_dataset/data//test_synthetic-00000-of-00001.parquet hf_dataset/data//train_original-00000-of-00001.parquet hf_dataset/data//train_synthetic-00000-of-00001.parquet hf_dataset/data//generation_log.json """ from __future__ import annotations import argparse import json import logging import subprocess import sys from datetime import UTC, datetime from pathlib import Path from random import Random from datasets import Dataset, DatasetDict import multilingual_gsm_symbolic from multilingual_gsm_symbolic import available_languages, load_data, load_replacements DEFAULT_SEED = 42 DEFAULT_N = 20 HF_DATA_DIR = Path(__file__).resolve().parent / "data" GENERATION_LOG = HF_DATA_DIR / "generation_log.json" TEMPLATE_DATA_ROOT = Path(multilingual_gsm_symbolic.__file__).resolve().parent / "data" / "templates" VALID_DATA_SPLITS = ("test", "train") logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s", datefmt="%H:%M:%S") logging.getLogger("multilingual_gsm_symbolic").setLevel(logging.WARNING) log = logging.getLogger(__name__) def _git_commit() -> str: try: return subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip() except Exception: return "unknown" def _extract_target(answer: str) -> str: return answer.split("####")[-1].strip() def build_original_rows(lang: str, split: str = "test") -> list[dict]: return [ { "question": template.question, "answer": template.answer, "target": _extract_target(template.answer), "language": lang, "source_id": template.id_orig, } for template in load_data(lang, directory=TEMPLATE_DATA_ROOT / lang / split) ] def build_synthetic_rows(lang: str, n: int, rng: Random, split: str = "test") -> list[dict]: replacements = load_replacements(lang) templates = load_data(lang, directory=TEMPLATE_DATA_ROOT / lang / split) 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, splits: list[str]) -> None: out_dir = HF_DATA_DIR / lang out_dir.mkdir(parents=True, exist_ok=True) dataset = DatasetDict() split_counts = {} available = [candidate for candidate in VALID_DATA_SPLITS if (TEMPLATE_DATA_ROOT / lang / candidate).exists()] for split in splits: if split not in available: print(f"[{lang}] Split '{split}' is not available for this language.") continue log.info(f"[{lang}] Building {split} original split...") original_rows = build_original_rows(lang, split=split) log.info(f"[{lang}] Building {split} synthetic split (n={n}, seed={seed})...") rng = Random(seed) synthetic_rows = build_synthetic_rows(lang, n=n, rng=rng, split=split) dataset[f"{split}_original"] = Dataset.from_list(original_rows) dataset[f"{split}_synthetic"] = Dataset.from_list(synthetic_rows) split_counts[f"{split}_n_original"] = len(original_rows) split_counts[f"{split}_n_synthetic"] = len(synthetic_rows) log.info(f"[{lang}] {dataset}") for split_name, split_dataset in dataset.items(): split_dataset.to_parquet(out_dir / f"{split_name}-00000-of-00001.parquet") log.info(f"[{lang}] Parquet files written to {out_dir}") # Update the shared generation log existing: dict = {} if GENERATION_LOG.exists(): existing = json.loads(GENERATION_LOG.read_text(encoding="utf-8")) existing[lang] = { "seed": seed, "n_synthetic_per_template": n, "commit": _git_commit(), "package_version": multilingual_gsm_symbolic.__version__, "generated_at": datetime.now(UTC).isoformat(), "splits": splits, **split_counts, } GENERATION_LOG.write_text(json.dumps(existing, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") log.info(f"[{lang}] Generation log updated at {GENERATION_LOG}") def main() -> None: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("--lang", default=None, help="Language code to generate (e.g. eng, dan); omit to generate all") parser.add_argument("--seed", type=int, default=DEFAULT_SEED, help=f"RNG seed (default: {DEFAULT_SEED})") parser.add_argument( "--n", type=int, default=DEFAULT_N, help=f"Synthetic questions per template (default: {DEFAULT_N})" ) parser.add_argument( "--split", choices=("test", "train", "both"), default="test", help="Dataset split to generate: test, train, or both (default: test)", ) args = parser.parse_args() available = available_languages() langs = list(available) if args.lang is None else [args.lang] splits = list(VALID_DATA_SPLITS) if args.split == "both" else [args.split] for lang in langs: 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, splits=splits) if __name__ == "__main__": main()