| """Upload the payload the Colab lanes need, to Jyo-K/PopTurk.
|
|
|
| export HF_TOKEN=hf_...
|
| python scripts/01_upload_hf.py --what code shards models --split test
|
|
|
| WHAT GOES UP, AND WHAT DELIBERATELY DOES NOT
|
|
|
| code this source tree (~120 KB). The notebook imports berx from it, so there is exactly
|
| one copy of the scoring logic and a fix on the box reaches Colab on the next push.
|
| shards the self-contained cross-encoder work units from 04_make_shards.py. Text included,
|
| so a lane needs nothing else.
|
| models the fine-tuned cross-encoder checkpoints. Weights ONLY - the optimiser state is
|
| 4.5 GB of AdamW moments that inference never reads.
|
| geo the mined administrative-equivalence tables (a few MB).
|
|
|
| NOT the embeddings. They are already in the three channel repos and they are 42 GB; a Colab
|
| lane does cross-encoder scoring, which needs no embeddings at all. Anything that pulls them
|
| into a Colab VM has misunderstood the split of work.
|
| NOT the raw dataset in full. The shards already carry the text they need.
|
|
|
| PRIVACY. Every repo is created PRIVATE. The competition data is licensed to participants, not
|
| to the public, and a public dataset repo is a redistribution. Passing --public is an explicit
|
| decision to publish; think before you do.
|
| """
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import glob
|
| import os
|
| import re
|
| import shutil
|
| import sys
|
| import tempfile
|
|
|
| sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
| from berx import io_hf
|
| from berx import paths as P
|
|
|
| ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
|
|
|
| TOKEN_RE = re.compile(r'^(HF_TOKEN\s*=\s*).*$', re.M)
|
| LEAK_RE = re.compile(r'hf_[A-Za-z0-9]{20,}')
|
|
|
|
|
|
|
| REDACTED = r'\1"" # redacted for upload'
|
|
|
| SKIP_IN_MODEL = {"opt.pt", "optimizer.pt", "scheduler.pt", "rng_state.pth",
|
| "trainer_state.json", "training_args.bin"}
|
|
|
|
|
| def push_code(repo: str, public: bool):
|
| """Upload the source tree, with the embedded token REDACTED.
|
|
|
| The token now lives in berx/io_hf.py so it does not have to be exported. That makes this
|
| function the one place it could leak: uploading the tree verbatim would publish the
|
| token inside the very repo it authenticates to. The redaction below is asserted, and the
|
| upload is refused outright if any token-shaped string survives it - a silent failure here
|
| means a live credential in a dataset repo.
|
| """
|
| tmp = tempfile.mkdtemp()
|
| dst = os.path.join(tmp, "code")
|
| shutil.copytree(os.path.join(ROOT, "berx"), os.path.join(dst, "berx"),
|
| ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
|
| shutil.copytree(os.path.join(ROOT, "scripts"), os.path.join(dst, "scripts"),
|
| ignore=shutil.ignore_patterns("__pycache__", "*.pyc"))
|
| for f in ("hf_token.txt",):
|
| q = os.path.join(dst, f)
|
| if os.path.exists(q):
|
| os.remove(q)
|
|
|
| redacted = 0
|
| for root, _, files in os.walk(dst):
|
| for fn in files:
|
| if not fn.endswith((".py", ".sh", ".md", ".txt", ".json", ".ipynb")):
|
| continue
|
| fp = os.path.join(root, fn)
|
| try:
|
| txt = open(fp, encoding="utf-8").read()
|
| except (UnicodeDecodeError, OSError):
|
| continue
|
| new_txt = TOKEN_RE.sub(REDACTED, txt)
|
| if new_txt != txt:
|
| open(fp, "w", encoding="utf-8").write(new_txt)
|
| redacted += 1
|
| leak = LEAK_RE.search(new_txt)
|
| assert not leak, (
|
| f"REFUSING TO UPLOAD: {fp} still contains something token-shaped "
|
| f"({leak.group(0)[:12]}...). Fix the redaction before publishing.")
|
| io_hf.upload(dst, "code", repo, public)
|
| shutil.rmtree(tmp, ignore_errors=True)
|
| print(f" code/ uploaded (token redacted in {redacted} file(s))")
|
|
|
|
|
| def push_shards(repo: str, split: str, public: bool):
|
| files = sorted(glob.glob(P.work("shards", f"{split}_shard*.parquet")))
|
| files += glob.glob(P.work("shards", f"{split}_manifest.json"))
|
| assert files, "no shards found - run 04_make_shards.py first"
|
| total = 0
|
| for f in files:
|
| mb = os.path.getsize(f) / 2 ** 20
|
| total += mb
|
| io_hf.upload(f, f"shards/{os.path.basename(f)}", repo, public)
|
| print(f" shards/{os.path.basename(f)} {mb:.1f} MB")
|
| print(f" {total:.1f} MB total")
|
|
|
|
|
| def push_model(repo: str, local: str, name: str, public: bool):
|
| assert os.path.isdir(local), f"not a directory: {local}"
|
| tmp = tempfile.mkdtemp()
|
| dst = os.path.join(tmp, name)
|
| os.makedirs(dst)
|
| kept = 0
|
| for f in os.listdir(local):
|
| if f in SKIP_IN_MODEL or f == "ckpt":
|
| continue
|
| src = os.path.join(local, f)
|
| if os.path.isfile(src):
|
| shutil.copy2(src, os.path.join(dst, f))
|
| kept += os.path.getsize(src)
|
| io_hf.upload(dst, f"models/{name}", repo, public)
|
| shutil.rmtree(tmp, ignore_errors=True)
|
| print(f" models/{name} {kept/2**30:.2f} GiB (optimiser state excluded)")
|
|
|
|
|
| def push_geo(repo: str, public: bool):
|
| for f in glob.glob(P.work("geo", "*.json")):
|
| io_hf.upload(f, f"geo/{os.path.basename(f)}", repo, public)
|
| print(f" geo/{os.path.basename(f)}")
|
|
|
|
|
| def main():
|
| ap = argparse.ArgumentParser()
|
| ap.add_argument("--what", nargs="+", required=True,
|
| choices=["code", "shards", "models", "geo", "all"])
|
| ap.add_argument("--split", default="test")
|
| ap.add_argument("--repo", default=P.PAYLOAD_REPO)
|
| ap.add_argument("--model-dirs", nargs="*", default=[],
|
| help="LOCAL_DIR:NAME pairs, e.g. work/ce_model_A:bge_reranker_ft")
|
| ap.add_argument("--token", default="", help="overrides every other token source")
|
| ap.add_argument("--public", action="store_true",
|
| help="publish instead of keeping the repo private - think first")
|
| a = ap.parse_args()
|
|
|
| if a.token:
|
| io_hf.set_token(a.token)
|
| if not io_hf.token():
|
| sys.exit("No token. Set HF_TOKEN in berx/io_hf.py, or pass --token, or put it in "
|
| "hf_token.txt, or export HF_TOKEN.")
|
| print(f"token from {io_hf.token_source()}")
|
| what = set(a.what)
|
| if "all" in what:
|
| what = {"code", "shards", "models", "geo"}
|
|
|
| io_hf.ensure_repo(a.repo, a.public)
|
| print(f"repo {a.repo} ({'PUBLIC' if a.public else 'private'})")
|
|
|
| if "code" in what:
|
| push_code(a.repo, a.public)
|
| if "shards" in what:
|
| push_shards(a.repo, a.split, a.public)
|
| if "geo" in what:
|
| push_geo(a.repo, a.public)
|
| if "models" in what:
|
| if not a.model_dirs:
|
| print(" --model-dirs not given; skipping models")
|
| for spec in a.model_dirs:
|
| local, _, name = spec.partition(":")
|
| push_model(a.repo, local, name or os.path.basename(local.rstrip("/")), a.public)
|
|
|
| print(f"\nhttps://huggingface.co/datasets/{a.repo}")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
