| """Sync the working tree to the HuggingFace dataset repo. |
| |
| Usage: |
| python scripts/upload_hf.py --dry-run |
| python scripts/upload_hf.py --include-runs main_ abl_ loao_ de_ |
| |
| Checkpoints (``model.pt``) are only uploaded for the tags listed in |
| ``KEEP_CKPT`` to keep the repo small; metrics/history/curves/predictions for |
| every run are always uploaded. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import os |
| from pathlib import Path |
|
|
| from huggingface_hub import HfApi |
|
|
| REPO = "eduzrh/training-model-material" |
| REPO_TYPE = "dataset" |
| ROOT = Path(__file__).resolve().parents[1] |
|
|
| |
| DIRS = ["code", "docs", "scripts", "data", "results/tables", "results/figures", |
| "report", "configs", "logs"] |
|
|
| IGNORE = ["**/__pycache__/**", "**/*.pyc", "**/.ipynb_checkpoints/**", |
| "**/*.pt", "**/predictions.npz", "**/_tables_ro/**", "**/_figures_ro/**"] |
|
|
| KEEP_CKPT: tuple[str, ...] = ("main_pimamba_f0_s0", "main_mamba_f0_s0", |
| "main_gru_f0_s0", "abl_pimamba_f0_s0", |
| "next_hymba_f0_s0", "v2_pimamba2_f0_s0") |
|
|
|
|
| def _token(explicit: str | None) -> str: |
| tok = explicit or os.environ.get("HF_TOKEN") |
| if not tok: |
| |
| try: |
| from huggingface_hub import get_token |
| tok = get_token() |
| except Exception: |
| tok = None |
| if not tok: |
| raise SystemExit("no HF token: pass --token, set HF_TOKEN or run hf login") |
| return tok |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--token", default=None) |
| ap.add_argument("--repo", default=REPO) |
| ap.add_argument("--include-runs", nargs="*", default=None, |
| help="only upload results/runs tags starting with these prefixes") |
| ap.add_argument("--dry-run", action="store_true") |
| ap.add_argument("--private", action="store_true") |
| a = ap.parse_args() |
|
|
| tok = _token(a.token) |
| api = HfApi(token=tok) |
| api.create_repo(a.repo, repo_type=REPO_TYPE, exist_ok=True, |
| private=a.private) |
|
|
| targets: list[Path] = [] |
| for d in DIRS: |
| p = ROOT / d |
| if p.exists(): |
| targets.append(p) |
|
|
| |
| |
| run_root = ROOT / "results" / "runs" |
| keep_tags = _summary_tags() |
| extra_ignore = list(IGNORE) |
| if run_root.exists(): |
| if a.include_runs: |
| for p in sorted(run_root.iterdir()): |
| if p.is_dir() and any(p.name.startswith(x) for x in a.include_runs): |
| targets.append(p) |
| else: |
| drop = {d.name for d in run_root.iterdir() if d.is_dir()} - keep_tags |
| extra_ignore += [f"{t}/**" for t in sorted(drop)] |
| targets.append(run_root) |
| print(f"bulk runs: keeping {len(keep_tags)} tags, skipping {len(drop)}") |
|
|
| for f in ["README.md", "requirements.txt", ".gitignore", |
| "results/RESULTS.md", "results/summary.csv"]: |
| p = ROOT / f |
| if p.exists(): |
| targets.append(p) |
|
|
| n_files = 0 |
| total = 0 |
| for p in targets: |
| rel = p.relative_to(ROOT).as_posix() |
| files = [p] if p.is_file() else [q for q in p.rglob("*") if q.is_file()] |
| files = [q for q in files if not _ignored(q.relative_to(ROOT).as_posix())] |
| if not files: |
| continue |
| size = sum(q.stat().st_size for q in files) |
| n_files += len(files) |
| total += size |
| print(f"{rel:45s} {len(files):5d} files {size/1e6:8.2f} MB") |
| if a.dry_run: |
| continue |
| if p.is_file(): |
| api.upload_file(path_or_fileobj=str(p), path_in_repo=rel, |
| repo_id=a.repo, repo_type=REPO_TYPE, |
| commit_message=f"sync {rel}") |
| continue |
| api.upload_folder(folder_path=str(p), path_in_repo=rel, repo_id=a.repo, |
| repo_type=REPO_TYPE, ignore_patterns=extra_ignore, |
| commit_message=f"sync {rel}") |
|
|
| |
| if not a.dry_run: |
| for m in ["mlp", "gru", "lstm", "transformer", "mamba", "mamba2", "pimamba"]: |
| for f in range(5): |
| pf = run_root / f"main_{m}_f{f}_s0" / "predictions.npz" |
| if pf.exists(): |
| api.upload_file(path_or_fileobj=str(pf), |
| path_in_repo=f"results/runs/main_{m}_f{f}_s0/predictions.npz", |
| repo_id=a.repo, repo_type=REPO_TYPE, |
| commit_message=f"oof predictions {m} f{f}") |
|
|
| |
| for tag in KEEP_CKPT: |
| ck = run_root / tag / "model.pt" |
| if ck.exists(): |
| print(f"checkpoint {tag} ({ck.stat().st_size/1e6:.1f} MB)") |
| if not a.dry_run: |
| api.upload_file(path_or_fileobj=str(ck), |
| path_in_repo=f"results/runs/{tag}/model.pt", |
| repo_id=a.repo, repo_type=REPO_TYPE, |
| commit_message=f"checkpoint {tag}") |
| print(f"\ntotal {n_files} files, {total/1e6:.1f} MB") |
|
|
|
|
| def _summary_tags() -> set[str]: |
| """Only publish runs that actually appear in results/summary.csv.""" |
| import csv |
| f = ROOT / "results" / "summary.csv" |
| if not f.exists(): |
| return set() |
| with f.open(encoding="utf-8") as fh: |
| return {r["tag"] for r in csv.DictReader(fh) if r.get("tag")} |
|
|
|
|
| def _ignored(rel: str) -> bool: |
| import fnmatch |
| for pat in IGNORE: |
| p = pat.replace("**/", "").replace("/**", "") |
| if fnmatch.fnmatch(rel, pat) or fnmatch.fnmatch(rel.split("/")[-1], p): |
| return True |
| if "/__pycache__/" in rel: |
| return True |
| return False |
|
|
|
|
| if __name__ == "__main__": |
| main() |
