Duplicate from st-taro/csen346_temp

.gitattributes

@@ -0,0 +1,57 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+mixed_pretrain/* filter=lfs diff=lfs merge=lfs -text
+*.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,17 @@
+---
+A mixture of datasets focused on Source/Intermediate Representation training for multilingual code generation.
+For SCU CSEN346.
+
+
+**Usage**:
+Pass to continued_pretrain.py with
+```
+  --dataset_name './tokenized_dataset'
+```
+
+
+Sources:
+UKPLab/SLTrans
+bigcode/the-stack
+allenai/peS2o
+open-web-math/open-web-math

build_ir_dataset.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+Transform the mixed_pretrain JSONL shards into a unified parquet dataset
+where every record has a source_code column and an llvm_ir column.
+
+SLTrans records already contain both — the <source> / <llvm_ir> tags are
+parsed out into separate columns.  Records from other sources (peS2o,
+TheStack, OpenWebMath) have their text placed in source_code and llvm_ir
+set to null, keeping the schema consistent.
+
+Output schema
+-------------
+  source_code    string    source code or prose text
+  llvm_ir        string    LLVM IR  (null for non-SLTrans records)
+  language       string    programming language or content category
+  ir_type        string    Perf_Optimized / Size_Optimized  (null if not SLTrans)
+  source_dataset string    sltrans | pes2o | the_stack | openwebmath
+  est_tokens     int64     whitespace token estimate
+
+Usage
+-----
+    python build_ir_dataset.py
+    python build_ir_dataset.py --input mixed_pretrain --output ir_dataset.parquet
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+# ── SLTrans text parsing ───────────────────────────────────────────────────────
+# Matches the format written by build_mixed_dataset.py:
+#   <source>\n{code}\n</source>\n<llvm_ir>\n{ir}\n</llvm_ir>
+_SOURCE_PAT = re.compile(r"<source>\n(.*?)\n</source>",  re.DOTALL)
+_IR_PAT     = re.compile(r"<llvm_ir>\n(.*?)\n</llvm_ir>", re.DOTALL)
+
+
+def parse_sltrans(text: str) -> tuple[str, str]:
+    src = _SOURCE_PAT.search(text)
+    ir  = _IR_PAT.search(text)
+    return (src.group(1) if src else ""), (ir.group(1) if ir else "")
+
+
+# ── language normalisation ─────────────────────────────────────────────────────
+# Maps non-SLTrans sources to a human-readable language/category label.
+def _language(source: str, meta: dict) -> str:
+    if source == "the_stack":
+        return meta.get("lang") or meta.get("language") or "code"
+    if source == "pes2o":
+        return "scientific"
+    if source == "openwebmath":
+        return "math"
+    return ""
+
+
+# ── record transformer ─────────────────────────────────────────────────────────
+def transform(rec: dict) -> dict:
+    source = rec["source"]
+    text   = rec.get("text", "")
+    meta   = rec.get("meta", {})
+
+    if source == "sltrans":
+        source_code, llvm_ir = parse_sltrans(text)
+        language = meta.get("language", "")
+        ir_type  = meta.get("ir_type", None)
+    elif source == "stack_llvm":
+        # Unpaired IR from TheStack: the text IS the IR, no corresponding source
+        source_code = None
+        llvm_ir     = text
+        language    = "LLVM"
+        ir_type     = None
+    else:
+        source_code = text
+        llvm_ir     = None
+        language    = _language(source, meta)
+        ir_type     = None
+
+    return {
+        "source_code":    source_code,
+        "llvm_ir":        llvm_ir,
+        "language":       language,
+        "ir_type":        ir_type,
+        "source_dataset": source,
+        "est_tokens":     rec.get("est_tokens", 0),
+    }
+
+
+# ── parquet schema ─────────────────────────────────────────────────────────────
+SCHEMA = pa.schema([
+    pa.field("source_code",    pa.large_utf8()),
+    pa.field("llvm_ir",        pa.large_utf8()),
+    pa.field("language",       pa.large_utf8()),
+    pa.field("ir_type",        pa.large_utf8()),
+    pa.field("source_dataset", pa.large_utf8()),
+    pa.field("est_tokens",     pa.int64()),
+])
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    ap.add_argument("--input",      default="mixed_pretrain",
+                    help="Directory containing JSONL shards (default: mixed_pretrain)")
+    ap.add_argument("--output",     default="ir_dataset.parquet",
+                    help="Output parquet path (default: ir_dataset.parquet)")
+    ap.add_argument("--batch-size", type=int, default=10_000,
+                    help="Records per parquet row group (default: 10000)")
+    args = ap.parse_args()
+
+    data_dir = Path(args.input)
+    if not data_dir.is_dir():
+        print(f"ERROR: input directory not found: {data_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    shards = sorted(data_dir.glob("*.jsonl"))
+    if not shards:
+        print(f"No JSONL files found in {data_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    out_path = Path(args.output)
+    print(f"Input  : {data_dir.resolve()}  ({len(shards)} shards)")
+    print(f"Output : {out_path.resolve()}")
+    print(f"Schema : {[f.name for f in SCHEMA]}")
+    print()
+
+    writer  = pq.ParquetWriter(out_path, SCHEMA)
+    batch: list[dict] = []
+    total = sltrans_ok = sltrans_partial = 0
+
+    def flush(rows: list[dict]) -> None:
+        df = pd.DataFrame(rows)
+        # Ensure all columns present even if batch is from a single source
+        for col in [f.name for f in SCHEMA]:
+            if col not in df.columns:
+                df[col] = None
+        df["est_tokens"] = df["est_tokens"].fillna(0).astype("int64")
+        table = pa.Table.from_pandas(df[[ f.name for f in SCHEMA ]], schema=SCHEMA)
+        writer.write_table(table)
+
+    for shard in tqdm(shards, desc="shards", unit="file"):
+        with shard.open(encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                rec = json.loads(line)
+                row = transform(rec)
+
+                if rec["source"] == "sltrans":
+                    if row["source_code"] and row["llvm_ir"]:
+                        sltrans_ok += 1
+                    else:
+                        sltrans_partial += 1
+
+                batch.append(row)
+                total += 1
+
+                if len(batch) >= args.batch_size:
+                    flush(batch)
+                    batch.clear()
+
+    if batch:
+        flush(batch)
+
+    writer.close()
+
+    # ── summary ────────────────────────────────────────────────────────────────
+    pf = pq.ParquetFile(out_path)
+    print()
+    print("=" * 60)
+    print("BUILD COMPLETE")
+    print("=" * 60)
+    print(f"Total records written : {total:,}")
+    print(f"SLTrans (both fields) : {sltrans_ok:,}")
+    if sltrans_partial:
+        print(f"SLTrans (parse miss)  : {sltrans_partial:,}  <- check text format")
+    print()
+    print("Output schema:")
+    print(pf.schema_arrow)
+    print()
+
+    # Quick per-source count from the written file
+    df = pf.read(columns=["source_dataset"]).to_pandas()
+    print("Records per source_dataset:")
+    for src, cnt in df["source_dataset"].value_counts().items():
+        print(f"  {src:<14} {cnt:>10,}")
+    print()
+    print(f"Output: {out_path.resolve()}")
+
+
+if __name__ == "__main__":
+    main()

build_mixed_dataset.py

@@ -0,0 +1,517 @@
+#!/usr/bin/env python3
+"""
+build_mixed_dataset.py — Five-source mixed pre-training corpus builder.
+
+Sources
+-------
+  SLTrans          local parquet  (balanced language x IR-type)   --sltrans-tokens
+  peS2o            allenai/peS2o  (open scientific papers)        --pes2o-tokens
+  TheStack (code)  bigcode/the-stack, non-LLVM languages          --stack-tokens
+  TheStack (LLVM)  bigcode/the-stack, lang=llvm  (unpaired IR)    --stack-llvm-tokens
+  OpenWebMath      open-web-math/open-web-math (math web text)    --owm-tokens
+
+Set any cap to 0 to skip that source.
+TheStack code and LLVM IR are streamed from the same HF dataset but kept
+as separate shards (the_stack-*.jsonl vs stack_llvm-*.jsonl) so downstream
+pipelines can weight them independently.
+
+Output
+------
+  JSONL shards under --output-dir, one filename prefix per source:
+    sltrans-00000.jsonl, pes2o-00000.jsonl, the_stack-00000.jsonl, ...
+  Each record:
+    {"text": "...", "source": "...", "meta": {...}, "est_tokens": N}
+  Plus manifest.json summarising the run.
+
+Usage
+-----
+  pip install "datasets>=2.18" pyarrow pandas tqdm
+  huggingface-cli login          # peS2o and the-stack are gated
+
+  python build_mixed_dataset.py
+  python build_mixed_dataset.py --sltrans-tokens 500e6 --owm-tokens 200e6
+  python build_mixed_dataset.py --stack-tokens 0              # skip code
+  python build_mixed_dataset.py --stack-langs python,rust,go
+  python build_mixed_dataset.py --stack-llvm-tokens 100e6     # 100M unpaired IR
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import re
+import socket
+import sys
+import time
+from pathlib import Path
+
+import pandas as pd
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+socket.setdefaulttimeout(90)
+
+# ── constants ──────────────────────────────────────────────────────────────────
+SLTRANS_PROBE_ROWS = 200
+SLTRANS_SKIP_DIRS  = {".venv", "__pycache__", ".git"}
+
+THE_STACK_LANGS = [
+    "python", "c", "c++", "rust", "go",
+    "java", "javascript", "typescript",
+]
+
+_TRANSIENT_ERRORS = ("ssl", "timeout", "handshake", "connection", "timed out")
+
+
+# ── token estimation ───────────────────────────────────────────────────────────
+
+def estimate_tokens(text: str) -> int:
+    return int(len(text.split()) * 1.5)
+
+
+# ── JSONL shard writer ─────────────────────────────────────────────────────────
+
+class ShardWriter:
+    def __init__(self, out_dir: Path, prefix: str, records_per_shard: int):
+        out_dir.mkdir(parents=True, exist_ok=True)
+        self._dir, self._pfx, self._rps = out_dir, prefix, records_per_shard
+        self._idx = self._n = 0
+        self._fh = None
+        self._roll()
+
+    def _roll(self):
+        if self._fh:
+            self._fh.close()
+        self._fh = (self._dir / f"{self._pfx}-{self._idx:05d}.jsonl").open("w", encoding="utf-8")
+        self._n = 0
+        self._idx += 1
+
+    def write(self, record: dict):
+        self._fh.write(json.dumps(record, ensure_ascii=False) + "\n")
+        self._n += 1
+        if self._n >= self._rps:
+            self._roll()
+
+    def close(self):
+        if self._fh:
+            self._fh.close()
+            self._fh = None
+
+
+# ── SLTrans (local parquet) ────────────────────────────────────────────────────
+
+def _sltrans_find_groups(root: Path) -> dict[tuple[str, str], list[Path]]:
+    """Return {(language, ir_type): [sorted shard paths]}."""
+    groups: dict[tuple[str, str], list[Path]] = {}
+    for d in sorted(root.iterdir()):
+        if not d.is_dir() or d.name in SLTRANS_SKIP_DIRS:
+            continue
+        for f in sorted(d.glob("*.parquet")):
+            m = re.match(r"^(Perf_Optimized|Size_Optimized)", f.name)
+            if m:
+                groups.setdefault((d.name, m.group(1)), []).append(f)
+    return groups
+
+
+def _pq_nrows(files: list[Path]) -> int:
+    return sum(pq.ParquetFile(f).metadata.num_rows for f in files)
+
+
+def _est_tok_df(src: pd.Series, ir: pd.Series) -> pd.Series:
+    src_w = src.fillna("").str.split().str.len().fillna(0)
+    ir_w  = ir.fillna("").str.split().str.len().fillna(0)
+    return ((src_w + ir_w + 5) * 1.5).astype(int)
+
+
+def _probe_avg_tokens(files: list[Path], n: int, rng: random.Random) -> float:
+    frames = []
+    seed = rng.randint(0, 2**31)
+    for f in files:
+        df = pq.ParquetFile(f).read_row_group(0).to_pandas()
+        if not df.empty:
+            frames.append(df.sample(min(n, len(df)), random_state=seed))
+        if sum(len(x) for x in frames) >= n:
+            break
+    if not frames:
+        return 0.0
+    p = pd.concat(frames, ignore_index=True).head(n)
+    p = p.dropna(subset=["Source_Code", "IR_Original"])
+    p = p[(p["Source_Code"] != "") & (p["IR_Original"] != "")]
+    return float(_est_tok_df(p["Source_Code"], p["IR_Original"]).mean()) if len(p) else 0.0
+
+
+def _sltrans_allocate(
+    groups: dict[tuple[str, str], list[Path]],
+    total: int,
+    rng: random.Random,
+) -> dict[tuple[str, str], int]:
+    """Equal-share budget with deficit redistribution for small groups."""
+    keys = sorted(groups)
+    avail: dict[tuple[str, str], int] = {}
+    for k in tqdm(keys, desc="      probe", unit="grp", leave=False):
+        rows = _pq_nrows(groups[k])
+        avg  = _probe_avg_tokens(groups[k], SLTRANS_PROBE_ROWS, rng)
+        avail[k] = int(rows * avg)
+        tqdm.write(
+            f"      {k[0]:>15}/{k[1]:<16}  ~{avail[k]:>14,} tok"
+            f"  ({rows:,} rows, avg {avg:.0f})"
+        )
+    budgets = {k: total // len(keys) for k in keys}
+    for _ in range(len(keys)):
+        capped  = {k: min(budgets[k], avail[k]) for k in keys}
+        deficit = sum(budgets[k] - capped[k] for k in keys)
+        if not deficit:
+            break
+        room = [k for k in keys if capped[k] < avail[k]]
+        if not room:
+            break
+        bonus = deficit // len(room)
+        for k in room:
+            capped[k] = min(capped[k] + bonus, avail[k])
+        budgets = capped
+    return budgets
+
+
+def write_sltrans(
+    root: Path,
+    budget: int,
+    writer: ShardWriter,
+    rng: random.Random,
+    min_tokens: int,
+) -> int:
+    groups = _sltrans_find_groups(root)
+    if not groups:
+        print(f"    WARNING: no SLTrans parquet files found in {root}", file=sys.stderr)
+        return 0
+
+    budgets = _sltrans_allocate(groups, budget, rng)
+    total_written = 0
+    bar = tqdm(total=budget, unit="tok", unit_scale=True,
+               desc="      write", dynamic_ncols=True)
+
+    for (lang, ir_type) in sorted(groups):
+        g_budget  = budgets[(lang, ir_type)]
+        g_written = 0
+        files = list(groups[(lang, ir_type)])
+        rng.shuffle(files)
+
+        for f in files:
+            if g_written >= g_budget:
+                break
+            pf = pq.ParquetFile(f)
+            for gi in range(pf.num_row_groups):
+                if g_written >= g_budget:
+                    break
+                df = pf.read_row_group(gi).to_pandas()
+                df = df.dropna(subset=["Source_Code", "IR_Original"])
+                df = df[(df["Source_Code"] != "") & (df["IR_Original"] != "")]
+                if df.empty:
+                    continue
+                df = df.sample(frac=1, random_state=rng.randint(0, 2**31)).reset_index(drop=True)
+                df["_t"] = _est_tok_df(df["Source_Code"], df["IR_Original"])
+
+                remaining = g_budget - g_written
+                cutoff = max(int((df["_t"].cumsum() <= remaining).sum()), 1)
+                for row in df.iloc[:cutoff].to_dict("records"):
+                    toks = int(row["_t"])
+                    if toks < min_tokens:
+                        continue
+                    text = (
+                        f"<source>\n{row['Source_Code']}\n</source>\n"
+                        f"<llvm_ir>\n{row['IR_Original']}\n</llvm_ir>"
+                    )
+                    writer.write({
+                        "text": text,
+                        "source": "sltrans",
+                        "meta": {"language": lang, "ir_type": ir_type},
+                        "est_tokens": toks,
+                    })
+                    g_written    += toks
+                    total_written += toks
+                    bar.update(min(toks, budget - bar.n))
+    bar.close()
+    return total_written
+
+
+# ── HuggingFace streaming ──────────────────────────────────────────────────────
+
+def _hf_open(
+    hf_path: str,
+    split: str = "train",
+    hf_config: str | None = None,
+    data_dir: str | None = None,
+):
+    """Open one HF streaming dataset with exponential-backoff retry."""
+    from datasets import load_dataset
+
+    kw: dict = {"split": split, "streaming": True, "trust_remote_code": True}
+    if hf_config:
+        kw["name"] = hf_config
+    if data_dir:
+        kw["data_dir"] = data_dir
+
+    for attempt in range(5):
+        try:
+            return load_dataset(hf_path, **kw)
+        except ValueError as e:
+            if "Bad split" in str(e):
+                return None
+            raise
+        except Exception as e:
+            if attempt < 4 and any(k in str(e).lower() for k in _TRANSIENT_ERRORS):
+                time.sleep(2 ** attempt)
+                continue
+            raise
+    return None
+
+
+def _hf_iter(
+    hf_path: str,
+    split: str = "train",
+    hf_config: str | None = None,
+):
+    """Yield rows from a HuggingFace streaming dataset."""
+    ds = _hf_open(hf_path, split=split, hf_config=hf_config)
+    if ds is not None:
+        yield from ds
+
+
+def write_hf_source(
+    source_name: str,
+    budget: int,
+    writer: ShardWriter,
+    rng: random.Random,
+    min_tokens: int,
+    hf_path: str,
+    text_fn,
+    meta_fn,
+    hf_config: str | None = None,
+    split: str = "train",
+    lang_filter: set[str] | None = None,
+) -> int:
+    written = skipped = 0
+    bar = tqdm(total=budget, unit="tok", unit_scale=True,
+               desc=f"      {source_name:<12}", dynamic_ncols=True, smoothing=0.05)
+    try:
+        for row in _hf_iter(hf_path, split=split, hf_config=hf_config):
+            if lang_filter is not None:
+                lang = (row.get("lang") or row.get("language") or "").lower()
+                if lang not in lang_filter:
+                    skipped += 1
+                    continue
+            text = text_fn(row)
+            if not text:
+                skipped += 1
+                continue
+            toks = estimate_tokens(text)
+            if toks < min_tokens:
+                skipped += 1
+                continue
+            writer.write({
+                "text": text,
+                "source": source_name,
+                "meta": meta_fn(row),
+                "est_tokens": toks,
+            })
+            written += toks
+            bar.update(min(toks, budget - bar.n))
+            if written >= budget:
+                break
+    finally:
+        bar.close()
+    print(f"      done: {written:,} tokens written, {skipped:,} rows skipped")
+    return written
+
+
+# ── text / meta extractors ─────────────────────────────────────────────────────
+
+def _get(row: dict, *keys: str, default: str = "") -> str:
+    for k in keys:
+        v = row.get(k)
+        if v:
+            return str(v)
+    return default
+
+
+def pes2o_text(row):  return _get(row, "text", "content")
+def pes2o_meta(row):  return {"id": _get(row, "id", "doc_id"), "source": _get(row, "source", "venue")}
+
+def stack_text(row):  return _get(row, "content", "text", "code")
+def stack_meta(row):  return {
+    "lang":    _get(row, "lang", "language"),
+    "repo":    _get(row, "max_stars_repo_name", "repo_name"),
+    "license": _get(row, "license"),
+}
+
+def owm_text(row):    return _get(row, "text")
+def owm_meta(row):    return {"url": _get(row, "url")}
+
+
+# ── main ───────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    ap.add_argument("--sltrans-root",   default=".",
+                    help="Root dir of downloaded SLTrans parquet files (default: .)")
+    ap.add_argument("--sltrans-tokens", type=float, default=700_000_000,
+                    help="Token cap for SLTrans   (default: 700M, 0=skip)")
+    ap.add_argument("--pes2o-tokens",   type=float, default=150_000_000,
+                    help="Token cap for peS2o     (default: 150M, 0=skip)")
+    ap.add_argument("--stack-tokens",      type=float, default=100_000_000,
+                    help="Token cap for TheStack source code  (default: 100M, 0=skip)")
+    ap.add_argument("--stack-llvm-tokens", type=float, default=0,
+                    help="Token cap for TheStack unpaired LLVM IR  (default: 0=skip)")
+    ap.add_argument("--owm-tokens",        type=float, default=50_000_000,
+                    help="Token cap for OpenWebMath (default: 50M, 0=skip)")
+    ap.add_argument("--stack-langs",       default=",".join(THE_STACK_LANGS),
+                    help="Comma-separated TheStack source-code language subsets (never includes llvm)")
+    ap.add_argument("--output-dir",     default="./mixed_pretrain",
+                    help="Output directory for JSONL shards (default: ./mixed_pretrain)")
+    ap.add_argument("--shard-size",     type=int, default=50_000,
+                    help="Records per JSONL shard (default: 50000)")
+    ap.add_argument("--min-tokens",     type=int, default=32,
+                    help="Drop records shorter than this (est. tokens, default: 32)")
+    ap.add_argument("--seed",           type=int, default=42)
+    args = ap.parse_args()
+
+    rng         = random.Random(args.seed)
+    out_dir     = Path(args.output_dir)
+    # Ensure "llvm" never leaks into the source-code filter.
+    stack_langs = [s.strip() for s in args.stack_langs.split(",")
+                   if s.strip() and s.strip().lower() != "llvm"]
+
+    budgets = {
+        "sltrans":     int(args.sltrans_tokens),
+        "pes2o":       int(args.pes2o_tokens),
+        "the_stack":   int(args.stack_tokens),
+        "stack_llvm":  int(args.stack_llvm_tokens),
+        "openwebmath": int(args.owm_tokens),
+    }
+    active_sources = [name for name, tok in budgets.items() if tok > 0]
+    total_budget   = sum(budgets.values())
+
+    print("=" * 64)
+    print("Mixed pre-training dataset builder")
+    print(f"  Output : {out_dir.resolve()}")
+    print(f"  Seed   : {args.seed}")
+    print()
+    for name, toks in budgets.items():
+        if toks > 0:
+            print(f"  {name:<14}  {toks:>15,} tokens")
+        else:
+            print(f"  {name:<14}  (skipped)")
+    print(f"  {'TOTAL':<14}  {total_budget:>15,} tokens")
+    print("=" * 64)
+
+    summary: dict[str, int] = {}
+    n_active = len(active_sources)
+    step = 1
+
+    # ── SLTrans ────────────────────────────────────────────────────────────────
+    if budgets["sltrans"] > 0:
+        print(f"\n[{step}/{n_active}] SLTrans  (local parquet, balanced language x IR-type)")
+        step += 1
+        w = ShardWriter(out_dir, "sltrans", args.shard_size)
+        try:
+            summary["sltrans"] = write_sltrans(
+                Path(args.sltrans_root), budgets["sltrans"], w, rng, args.min_tokens,
+            )
+        finally:
+            w.close()
+
+    # ── peS2o ──────────────────────────────────────────────────────────────────
+    if budgets["pes2o"] > 0:
+        print(f"\n[{step}/{n_active}] peS2o  (allenai/peS2o, config=v2)")
+        step += 1
+        w = ShardWriter(out_dir, "pes2o", args.shard_size)
+        try:
+            summary["pes2o"] = write_hf_source(
+                "pes2o", budgets["pes2o"], w, rng, args.min_tokens,
+                hf_path="allenai/peS2o",
+                text_fn=pes2o_text, meta_fn=pes2o_meta,
+                hf_config="v2",
+            )
+        finally:
+            w.close()
+
+    # ── TheStack ───────────────────────────────────────────────────────────────
+    if budgets["the_stack"] > 0:
+        print(f"\n[{step}/{n_active}] TheStack  (bigcode/the-stack, {len(stack_langs)} language subsets)")
+        print(f"      langs: {', '.join(stack_langs)}")
+        step += 1
+        w = ShardWriter(out_dir, "the_stack", args.shard_size)
+        try:
+            summary["the_stack"] = write_hf_source(
+                "the_stack", budgets["the_stack"], w, rng, args.min_tokens,
+                hf_path="bigcode/the-stack",
+                text_fn=stack_text, meta_fn=stack_meta,
+                lang_filter={l.lower() for l in stack_langs},
+            )
+        finally:
+            w.close()
+
+    # ── TheStack LLVM IR (unpaired) ────────────────────────────────────────────
+    if budgets["stack_llvm"] > 0:
+        print(f"\n[{step}/{n_active}] TheStack LLVM IR  (bigcode/the-stack, lang=llvm, unpaired)")
+        step += 1
+        w = ShardWriter(out_dir, "stack_llvm", args.shard_size)
+        try:
+            summary["stack_llvm"] = write_hf_source(
+                "stack_llvm", budgets["stack_llvm"], w, rng, args.min_tokens,
+                hf_path="bigcode/the-stack",
+                text_fn=stack_text, meta_fn=stack_meta,
+                lang_filter={"llvm"},
+            )
+        finally:
+            w.close()
+
+    # ── OpenWebMath ────────────────────────────────────────────────────────────
+    if budgets["openwebmath"] > 0:
+        print(f"\n[{step}/{n_active}] OpenWebMath  (open-web-math/open-web-math)")
+        w = ShardWriter(out_dir, "openwebmath", args.shard_size)
+        try:
+            summary["openwebmath"] = write_hf_source(
+                "openwebmath", budgets["openwebmath"], w, rng, args.min_tokens,
+                hf_path="open-web-math/open-web-math",
+                text_fn=owm_text, meta_fn=owm_meta,
+            )
+        finally:
+            w.close()
+
+    # ── manifest ───────────────────────────────────────────────────────────────
+    manifest = {
+        "seed":                    args.seed,
+        "min_tokens_per_record":   args.min_tokens,
+        "sources": {
+            "sltrans":     {"root":     args.sltrans_root,                 "target_tokens": budgets["sltrans"]},
+            "pes2o":       {"hf_path":  "allenai/peS2o",                  "target_tokens": budgets["pes2o"]},
+            "the_stack":   {"hf_path":  "bigcode/the-stack",              "target_tokens": budgets["the_stack"],     "langs": stack_langs},
+            "stack_llvm":  {"hf_path":  "bigcode/the-stack",              "target_tokens": budgets["stack_llvm"],    "langs": ["llvm"]},
+            "openwebmath": {"hf_path":  "open-web-math/open-web-math",    "target_tokens": budgets["openwebmath"]},
+        },
+        "tokens_written": summary,
+    }
+    (out_dir / "manifest.json").write_text(json.dumps(manifest, indent=2))
+
+    # ── summary ────────────────────────────────────────────────────────────────
+    grand = sum(summary.values())
+    print("\n" + "=" * 62)
+    print(f"{'Source':<14}  {'Target':>15}  {'Written':>15}  {'Share':>6}")
+    print("-" * 58)
+    for name in ["sltrans", "pes2o", "the_stack", "stack_llvm", "openwebmath"]:
+        if budgets[name] == 0:
+            continue
+        written = summary.get(name, 0)
+        pct     = 100 * written / grand if grand else 0
+        print(f"{name:<14}  {budgets[name]:>15,}  {written:>15,}  {pct:>5.1f}%")
+    print("-" * 58)
+    print(f"{'TOTAL':<14}  {total_budget:>15,}  {grand:>15,}  100.0%")
+    print(f"\nOutput: {out_dir.resolve()}")
+
+
+if __name__ == "__main__":
+    main()

build_pretrain_dataset.py

@@ -0,0 +1,456 @@
+"""
+Build a mixed continued-pretraining dataset for a code LM.
+
+Sources (streamed from the Hub — no full download):
+  - UKPLab/SLTrans         (LLVM IR <-> source pairs; primary IRCoder signal)
+  - allenai/peS2o          (open scientific text)
+  - bigcode/the-stack      (permissively licensed source code)
+
+Mixing target (token-weighted): 70 / 15 / 15.
+
+Output: JSONL shards under OUT_DIR. Each line:
+    {"text": "...", "source": "sltrans" | "pes2o" | "the_stack", "meta": {...}}
+
+The token budget is approximate — we use a fast whitespace token estimate by default
+to avoid pulling a heavy tokenizer into the streaming loop. Swap in a real tokenizer
+(see TOKENIZER section) if you want exact counts against your model's vocab.
+
+Usage:
+    pip install "datasets>=2.18" huggingface_hub tqdm
+    huggingface-cli login        # SLTrans + the-stack are gated; you must accept their terms
+    python build_pretrain_dataset.py
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import random
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Iterator
+
+import socket
+
+from datasets import interleave_datasets, load_dataset
+from tqdm import tqdm
+
+# Install hf-transfer and set this env var for significantly faster shard downloads.
+# pip install hf-transfer
+os.environ.setdefault("HF_HUB_ENABLE_HF_TRANSFER", "1")
+# Raise the per-shard download timeout (default 10s is too short for HF CDN under load).
+os.environ.setdefault("HF_HUB_DOWNLOAD_TIMEOUT", "120")
+
+# Apply a 90s socket-level timeout to every connection in this process.
+# This covers HF Hub file-listing API calls (which have no timeout by default)
+# and prevents indefinite hangs at 'resolving data files'.
+socket.setdefaulttimeout(90)
+
+# ============================================================================
+# CONFIG
+# ============================================================================
+
+@dataclass
+class SourceSpec:
+    name: str                       # short id used in output records
+    hf_path: str                    # HF dataset path
+    hf_config: str | None           # config name, if any
+    split: str                      # split to stream
+    target_fraction: float          # share of the total token budget
+    text_fn: Callable[[dict], str]  # extracts the training text from a row
+    meta_fn: Callable[[dict], dict] # extracts a small metadata dict
+    # the-stack is organized by language subset; SLTrans by source language.
+    # If `subsets` is set, we round-robin over them, each loaded as a separate stream.
+    subsets: list[str] | None = None
+
+
+# Total tokens in the final dataset (approximate).
+TOTAL_TOKEN_BUDGET = 1_500_000_000
+
+# Per-record length filters (in estimated tokens).
+MIN_TOKENS_PER_RECORD = 32
+MAX_TOKENS_PER_RECORD = 8192
+
+# Output.
+OUT_DIR = Path("./pretrain_mix")
+SHARD_RECORDS = 50_000               # records per .jsonl shard
+SEED = 17
+
+# Reservoir / sampling. We don't reservoir-sample (would require knowing N);
+# instead we accept records with probability `keep_prob` per source, tuned so
+# the stream yields roughly the target token count before exhaustion. Set to
+# 1.0 to take everything until budget is hit.
+KEEP_PROB = {
+    "sltrans":   1.0,
+    "pes2o":     1.0,
+    "the_stack": 0.5,   # the-stack is huge; subsample to diversify languages
+}
+
+# For the-stack, list languages you want represented. Keep this short for a
+# focused replication; expand for broader code coverage.
+THE_STACK_LANGS = [
+    "python", "c", "cpp", "rust", "go", "java", "javascript", "typescript",
+]
+
+# SLTrans subsets (source languages whose IR we want). None => use default split.
+SLTRANS_SUBSETS = [
+    f"{lang}/{split}"
+    for lang in ["C", "C++", "D", "Fortran", "Go", "Haskell", "Nim", "Objective-C", "Python", "Rust", "Swift"]
+    for split in ["Perf_Optimized", "Size_Optimized"]
+]
+
+# ============================================================================
+# TEXT / META EXTRACTORS
+# ============================================================================
+# These are intentionally defensive — different dataset versions name fields
+# differently. Adjust if a `KeyError` shows up in your run.
+
+def _first_present(row: dict, keys: list[str], default: str = "") -> str:
+    for k in keys:
+        if k in row and row[k]:
+            return row[k]
+    return default
+
+
+def sltrans_text(row: dict) -> str:
+    """SLTrans pairs source code with its LLVM IR. Concatenate with a marker so
+    the model learns to associate them — IRCoder-style."""
+    src = _first_present(row, ["source", "code", "src", "input"])
+    ir  = _first_present(row, ["ir", "llvm_ir", "llvm", "target", "output"])
+    if not src or not ir:
+        return ""
+    return f"<source>\n{src}\n</source>\n<llvm_ir>\n{ir}\n</llvm_ir>"
+
+
+def sltrans_meta(row: dict) -> dict:
+    return {
+        "lang": _first_present(row, ["language", "lang", "source_lang"]),
+    }
+
+
+def pes2o_text(row: dict) -> str:
+    return _first_present(row, ["text", "content"])
+
+
+def pes2o_meta(row: dict) -> dict:
+    return {
+        "id":     _first_present(row, ["id", "doc_id"]),
+        "source": _first_present(row, ["source", "venue"]),
+    }
+
+
+def the_stack_text(row: dict) -> str:
+    return _first_present(row, ["content", "text", "code"])
+
+
+def the_stack_meta(row: dict) -> dict:
+    return {
+        "lang":    _first_present(row, ["lang", "language"]),
+        "repo":    _first_present(row, ["max_stars_repo_name", "repo_name"]),
+        "license": _first_present(row, ["license"]),
+    }
+
+
+# ============================================================================
+# SOURCES
+# ============================================================================
+
+SOURCES: list[SourceSpec] = [
+    SourceSpec(
+        name="sltrans",
+        hf_path="UKPLab/SLTrans",
+        hf_config=None,
+        split="train",
+        target_fraction=0.70,
+        text_fn=sltrans_text,
+        meta_fn=sltrans_meta,
+        subsets=SLTRANS_SUBSETS,
+    ),
+    SourceSpec(
+        name="pes2o",
+        hf_path="allenai/peS2o",
+        hf_config="v2",
+        split="train",
+        target_fraction=0.15,
+        text_fn=pes2o_text,
+        meta_fn=pes2o_meta,
+    ),
+    SourceSpec(
+        name="the_stack",
+        hf_path="bigcode/the-stack",
+        hf_config=None,
+        # the-stack uses `data_dir` per language rather than HF configs.
+        split="train",
+        target_fraction=0.15,
+        text_fn=the_stack_text,
+        meta_fn=the_stack_meta,
+        subsets=THE_STACK_LANGS,
+    ),
+]
+
+
+# ============================================================================
+# TOKEN ESTIMATOR
+# ============================================================================
+# Whitespace-based estimate. For BPE tokenizers, real tokens ~= 1.3x words for
+# natural language and ~1.5–2x for code. We bake a 1.5x correction in here so
+# the budget is honest enough for planning. If you want exact counts:
+#
+#   from transformers import AutoTokenizer
+#   tok = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-3B")
+#   def estimate_tokens(text: str) -> int:
+#       return len(tok.encode(text, add_special_tokens=False))
+
+def estimate_tokens(text: str) -> int:
+    return int(len(text.split()) * 1.5)
+
+
+# ============================================================================
+# STREAMING
+# ============================================================================
+
+def open_stream(spec: SourceSpec, subset: str | None):
+    """Return an IterableDataset for a (source, subset) pair, or None if unavailable."""
+    kwargs = {"split": spec.split, "streaming": True}
+    if spec.hf_config is not None:
+        kwargs["name"] = spec.hf_config
+
+    # the-stack uses data_dir to select a language.
+    if spec.hf_path == "bigcode/the-stack" and subset is not None:
+        kwargs["data_dir"] = f"data/{subset}"
+
+    # SLTrans subsets are encoded as "Lang/Split" (e.g. "Python/Perf_Optimized").
+    if spec.hf_path == "UKPLab/SLTrans" and subset is not None:
+        lang, slt_split = subset.rsplit("/", 1)
+        kwargs["name"] = lang
+        kwargs["split"] = slt_split
+
+    _TRANSIENT = ("ssl", "timeout", "handshake", "connection", "timed out")
+    for attempt in range(5):
+        try:
+            return load_dataset(spec.hf_path, **kwargs)
+        except ValueError as e:
+            if "Bad split" in str(e):
+                return None
+            raise
+        except Exception as e:
+            if attempt < 4 and any(k in str(e).lower() for k in _TRANSIENT):
+                time.sleep(2 ** attempt)  # 1s, 2s, 4s, 8s
+                continue
+            raise
+    return None
+
+
+def round_robin(spec: SourceSpec) -> Iterator[dict]:
+    """Yield rows from the source, interleaving across subsets if any.
+
+    Data-file resolution (the HF Hub HTTP round-trips that show as
+    'resolving data files') is parallelised across subsets so all
+    metadata fetches happen concurrently instead of one-by-one.
+    """
+    if not spec.subsets:
+        ds = open_stream(spec, None)
+        if ds is not None:
+            yield from ds
+        return
+
+    # Resolve all subset streams in parallel — resolution is I/O-bound so
+    # threads eliminate most of the serial 'resolving data files' wait.
+    with ThreadPoolExecutor(max_workers=min(4, len(spec.subsets))) as pool:
+        results = list(pool.map(open_stream, [spec] * len(spec.subsets), spec.subsets))
+
+    datasets = [ds for ds in results if ds is not None]
+    if not datasets:
+        return
+
+    yield from interleave_datasets(datasets, stopping_strategy="all_exhausted")
+
+
+# ============================================================================
+# WRITER
+# ============================================================================
+
+class ShardWriter:
+    def __init__(self, out_dir: Path, prefix: str, records_per_shard: int):
+        self.out_dir = out_dir
+        self.prefix = prefix
+        self.records_per_shard = records_per_shard
+        self.out_dir.mkdir(parents=True, exist_ok=True)
+        self._shard_idx = 0
+        self._records_in_shard = 0
+        self._fh = None
+        self._open_new_shard()
+
+    def _open_new_shard(self) -> None:
+        if self._fh is not None:
+            self._fh.close()
+        path = self.out_dir / f"{self.prefix}-{self._shard_idx:05d}.jsonl"
+        self._fh = path.open("w", encoding="utf-8")
+        self._records_in_shard = 0
+        self._shard_idx += 1
+
+    def write(self, record: dict) -> None:
+        self._fh.write(json.dumps(record, ensure_ascii=False) + "\n")
+        self._records_in_shard += 1
+        if self._records_in_shard >= self.records_per_shard:
+            self._open_new_shard()
+
+    def close(self) -> None:
+        if self._fh is not None:
+            self._fh.close()
+            self._fh = None
+
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+def sample_source(spec: SourceSpec, target_tokens: int, writer: ShardWriter,
+                  rng: random.Random) -> int:
+    """Stream `spec` until ~target_tokens have been written. Returns tokens written."""
+    keep_prob = KEEP_PROB.get(spec.name, 1.0)
+    tokens_written = 0
+    records_written = 0
+    rows_seen = 0
+    rows_skipped_filter = 0
+    rows_skipped_subsample = 0
+    rows_skipped_empty = 0
+    started = time.time()
+
+    # tqdm bar measured in tokens — the unit that actually matters for the budget.
+    # `unit_scale=True` formats large counts as 1.23M / 1.23B automatically.
+    bar = tqdm(
+        total=target_tokens,
+        unit="tok",
+        unit_scale=True,
+        desc=f"{spec.name:>10}",
+        dynamic_ncols=True,
+        smoothing=0.05,
+    )
+
+    def _refresh_postfix() -> None:
+        elapsed = max(time.time() - started, 1e-6)
+        bar.set_postfix({
+            "records": f"{records_written:,}",
+            "rows":    f"{rows_seen:,}",
+            "tok/s":   f"{tokens_written/elapsed:,.0f}",
+            "skip":    f"{rows_skipped_filter+rows_skipped_subsample+rows_skipped_empty:,}",
+        }, refresh=False)
+
+    try:
+        for row in round_robin(spec):
+            rows_seen += 1
+
+            if keep_prob < 1.0 and rng.random() > keep_prob:
+                rows_skipped_subsample += 1
+                continue
+
+            try:
+                text = spec.text_fn(row)
+            except Exception as e:
+                if rows_seen <= 3:
+                    bar.write(f"[{spec.name}] text_fn error on row {rows_seen}: {e!r}")
+                rows_skipped_empty += 1
+                continue
+
+            if not text:
+                rows_skipped_empty += 1
+                continue
+
+            n_tok = estimate_tokens(text)
+            if n_tok < MIN_TOKENS_PER_RECORD or n_tok > MAX_TOKENS_PER_RECORD:
+                rows_skipped_filter += 1
+                continue
+
+            record = {
+                "text":   text,
+                "source": spec.name,
+                "meta":   spec.meta_fn(row),
+                "est_tokens": n_tok,
+            }
+            writer.write(record)
+            tokens_written += n_tok
+            records_written += 1
+
+            # Don't overshoot the bar (tqdm clamps, but `min` keeps the math clean).
+            bar.update(min(n_tok, target_tokens - bar.n))
+
+            # Refresh the postfix every ~1k records — cheaper than every step.
+            if records_written % 1_000 == 0:
+                _refresh_postfix()
+
+            if tokens_written >= target_tokens:
+                break
+
+        _refresh_postfix()
+    finally:
+        bar.close()
+
+    elapsed = time.time() - started
+    print(f"[{spec.name}] DONE: {records_written:,} records, "
+          f"{tokens_written:,} tokens, {rows_seen:,} rows seen, "
+          f"skipped(filter={rows_skipped_filter:,} subsample={rows_skipped_subsample:,} "
+          f"empty={rows_skipped_empty:,}), {elapsed:.0f}s")
+    return tokens_written
+
+
+def main() -> None:
+    rng = random.Random(SEED)
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Sanity-check fractions sum to ~1.
+    total_frac = sum(s.target_fraction for s in SOURCES)
+    if abs(total_frac - 1.0) > 1e-3:
+        print(f"WARN: source fractions sum to {total_frac}, not 1.0", file=sys.stderr)
+
+    # Banner — reassures the user something is happening before HF streams open.
+    print("=" * 64)
+    print(f"Building mixed pretrain corpus  →  {OUT_DIR.resolve()}")
+    print(f"Total token budget: {TOTAL_TOKEN_BUDGET:,}")
+    print(f"Per-record range: {MIN_TOKENS_PER_RECORD}–{MAX_TOKENS_PER_RECORD} tokens")
+    for s in SOURCES:
+        target = int(TOTAL_TOKEN_BUDGET * s.target_fraction)
+        kp = KEEP_PROB.get(s.name, 1.0)
+        subs = f", subsets={s.subsets}" if s.subsets else ""
+        print(f"  - {s.name:>10}: {s.target_fraction:>5.0%} → {target:>15,} tok  "
+              f"[keep_prob={kp}{subs}]")
+    print("=" * 64)
+
+    summary = {}
+    for spec in SOURCES:
+        target = int(TOTAL_TOKEN_BUDGET * spec.target_fraction)
+        writer = ShardWriter(OUT_DIR, prefix=spec.name,
+                             records_per_shard=SHARD_RECORDS)
+        try:
+            written = sample_source(spec, target, writer, rng)
+        finally:
+            writer.close()
+        summary[spec.name] = {"target": target, "written": written}
+
+    # Manifest.
+    manifest = {
+        "total_token_budget": TOTAL_TOKEN_BUDGET,
+        "seed": SEED,
+        "sources": [
+            {"name": s.name, "hf_path": s.hf_path,
+             "fraction": s.target_fraction, "subsets": s.subsets}
+            for s in SOURCES
+        ],
+        "tokens_written": summary,
+    }
+    (OUT_DIR / "manifest.json").write_text(json.dumps(manifest, indent=2))
+
+    print("\n=== SUMMARY ===")
+    grand_total = sum(v["written"] for v in summary.values())
+    for name, v in summary.items():
+        pct = 100 * v["written"] / grand_total if grand_total else 0
+        print(f"  {name:>10}: {v['written']:>15,} tokens ({pct:5.1f}%)")
+    print(f"  {'TOTAL':>10}: {grand_total:>15,} tokens")
+    print(f"\nOutput: {OUT_DIR.resolve()}")
+
+
+if __name__ == "__main__":
+    main()

pretraining_mix_raw.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:82c53eafe054a1e7938644fe60e4cdbdf3f321768738294beb8719acaa5db0e3
+size 1442069968

sltrans_subsets/sltrans_subset_1500M.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d896c84650b6dd23943264c919d898f215eb147c264df4c9ad2d1e28f715817d
+size 2230258908

sltrans_subsets/sltrans_subset_500M.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfac595fae04a9f8faf34f66d4ac1c555203259aab3e2717a7d3e5f49f47c368
+size 737917857

sltrans_subsets/sltrans_subset_700M.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b44b696df0b58b07f6b88192da9aa022d16edaf21aefa45eaaabddb88e269a77
+size 1021734608

tokenize_for_training.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""
+tokenize_for_training.py — Tokenize and chunk ir_dataset.parquet into a
+HuggingFace dataset ready for continued_pretrain.py.
+
+Pipeline position: AFTER build_ir_dataset.py, BEFORE continued_pretrain.py
+
+Input
+-----
+  Parquet file produced by build_ir_dataset.py with columns:
+    source_code, llvm_ir, language, ir_type, source_dataset, est_tokens
+
+Processing
+----------
+  1. Assemble one text string per record:
+       sltrans    → <source>\\n{code}\\n</source>\\n<llvm_ir>\\n{ir}\\n</llvm_ir>
+       stack_llvm → {llvm_ir}  (unpaired IR, no source)
+       others     → {source_code}  (peS2o, TheStack, OpenWebMath)
+  2. Tokenize each string without truncation, append an EOS token as a
+     document separator.
+  3. Concatenate all token sequences into one stream, split into
+     fixed-length blocks of --block-size tokens.
+  4. Emit records with input_ids / attention_mask / labels columns.
+     labels == input_ids (the Trainer shifts internally for causal LM loss).
+
+Output
+------
+  Arrow dataset saved with save_to_disk(), optionally pushed to the Hub.
+  Load locally:  datasets.load_from_disk("./tokenized_dataset")
+  Load from Hub: datasets.load_dataset("your-org/your-dataset")
+
+  NOTE: continued_pretrain.py uses load_dataset(...), so either push to Hub
+  or replace that call with load_from_disk() for a purely local workflow.
+
+Usage
+-----
+  python tokenize_for_training.py \\
+      --input ir_dataset.parquet \\
+      --model bigcode/starcoderbase-1b \\
+      --output ./tokenized_dataset
+
+  python tokenize_for_training.py \\
+      --input ir_dataset.parquet \\
+      --model codellama/CodeLlama-7b-hf \\
+      --output ./tokenized_dataset \\
+      --validation-split 0.05 \\
+      --push-to-hub your-org/dataset-name \\
+      --token YOUR_HF_TOKEN
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from itertools import chain
+
+from datasets import Dataset, DatasetDict
+from transformers import AutoTokenizer
+
+# Special tokens the IRCoder paper adds to every model's vocabulary.
+_IR_SPECIAL_TOKENS = ["<source_to_llvm>", "<llvm_to_source>"]
+_PAD_TOKEN = "<|pad|>"
+
+# Records per batch during the group_texts step.  Larger batches waste fewer
+# tokens at chunk boundaries.
+_GROUP_BATCH_SIZE = 5_000
+
+
+# ── tokenizer setup ────────────────────────────────────────────────────────────
+
+def build_tokenizer(model_name: str, block_size: int | None, token: str | None) -> AutoTokenizer:
+    """Load tokenizer and register the IRCoder special tokens."""
+    tok = AutoTokenizer.from_pretrained(
+        model_name,
+        padding_side="left",
+        truncation_side="right",
+        trust_remote_code=True,
+        token=token,
+    )
+
+    tokens_to_add: dict = {}
+
+    if tok.pad_token is None:
+        tokens_to_add["pad_token"] = _PAD_TOKEN
+
+    extra = [t for t in _IR_SPECIAL_TOKENS if t not in tok.get_vocab()]
+    existing_extra = list(tok.extra_special_tokens or [])
+    new_extra = [t for t in extra if t not in existing_extra]
+    if new_extra:
+        tokens_to_add["additional_special_tokens"] = existing_extra + new_extra
+
+    if tokens_to_add:
+        tok.add_special_tokens(tokens_to_add)
+
+    if block_size is not None:
+        tok.model_max_length = block_size
+    elif tok.model_max_length > 1_000_000:
+        # HuggingFace sets model_max_length to a huge sentinel when the tokenizer
+        # config doesn't specify a context length. Fall back to the value used by
+        # the IRCoder paper for all StarCoder/DeepSeek/CodeLlama models.
+        tok.model_max_length = 4096
+        print(f"  WARNING: tokenizer did not report a context length; defaulting "
+              f"to {tok.model_max_length}. Pass --block-size to override.")
+
+    return tok
+
+
+# ── text assembly ──────────────────────────────────────────────────────────────
+
+def _assemble_text_batch(batch: dict) -> dict:
+    """Derive a single 'text' string for each record."""
+    texts: list[str | None] = []
+    for src, ir, source in zip(
+        batch["source_code"], batch["llvm_ir"], batch["source_dataset"]
+    ):
+        if source == "sltrans":
+            if src and ir:
+                texts.append(
+                    f"<source>\n{src}\n</source>\n<llvm_ir>\n{ir}\n</llvm_ir>"
+                )
+            else:
+                texts.append(None)
+        elif source == "stack_llvm":
+            texts.append(str(ir) if ir else None)
+        else:
+            texts.append(str(src) if src else None)
+    return {"text": texts}
+
+
+def _is_valid(example: dict) -> bool:
+    t = example["text"]
+    return t is not None and t != ""
+
+
+# ── tokenisation ───────────────────────────────────────────────────────────────
+
+def _tokenize_batch(batch: dict, tokenizer: AutoTokenizer) -> dict:
+    """Tokenize text without truncation; append EOS as a document separator."""
+    eos = tokenizer.eos_token_id
+    if eos is None:
+        raise ValueError(
+            f"Tokenizer for {tokenizer.name_or_path!r} has no eos_token_id. "
+            "Set one explicitly before running this script."
+        )
+
+    encoded = tokenizer(
+        batch["text"],
+        add_special_tokens=False,
+        truncation=False,
+        padding=False,
+    )
+    return {
+        "input_ids":      [ids + [eos] for ids in encoded["input_ids"]],
+        "attention_mask": [am  + [1]   for am  in encoded["attention_mask"]],
+    }
+
+
+# ── chunking ───────────────────────────────────────────────────────────────────
+
+def _group_texts(batch: dict, block_size: int) -> dict:
+    """Concatenate token sequences and split into fixed-length blocks."""
+    all_ids = list(chain.from_iterable(batch["input_ids"]))
+    total = (len(all_ids) // block_size) * block_size
+    if total == 0:
+        return {"input_ids": [], "attention_mask": [], "labels": []}
+
+    num_blocks = total // block_size
+    ids_list = [all_ids[i : i + block_size] for i in range(0, total, block_size)]
+    am_row = [1] * block_size
+
+    return {
+        "input_ids": ids_list,
+        "attention_mask": [am_row] * num_blocks,
+        "labels": ids_list,
+    }
+
+
+# ── main ───────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    ap.add_argument(
+        "--input", default="ir_dataset.parquet",
+        help="Parquet file from build_ir_dataset.py (default: ir_dataset.parquet)",
+    )
+    ap.add_argument(
+        "--model", required=True,
+        help="HuggingFace model name — selects the tokenizer "
+             "(e.g. bigcode/starcoderbase-1b)",
+    )
+    ap.add_argument(
+        "--output", default="./tokenized_dataset",
+        help="Directory for the Arrow dataset (default: ./tokenized_dataset)",
+    )
+    ap.add_argument(
+        "--block-size", type=int, default=None,
+        help="Token block length. Defaults to the tokenizer's model_max_length "
+             "(4096 for StarCoder/DeepSeek/CodeLlama, 2048 for CodeGen).",
+    )
+    ap.add_argument(
+        "--num-workers", type=int, default=1,
+        help="Parallel workers for dataset.map (default: 1). "
+             "Increase on Linux; keep at 1 on Windows to avoid spawn issues.",
+    )
+    ap.add_argument(
+        "--validation-split", type=float, default=0.0,
+        help="Fraction of blocks to hold out as validation (default: 0 = no split). "
+             "The training script can also split at runtime via "
+             "--validation_split_percentage.",
+    )
+    ap.add_argument(
+        "--push-to-hub", default=None, metavar="HUB_DATASET_ID",
+        help="Push the finished dataset to the Hub (e.g. your-org/dataset-name).",
+    )
+    ap.add_argument(
+        "--token", default=None,
+        help="HuggingFace token (required for gated models and Hub push).",
+    )
+    args = ap.parse_args()
+
+    in_path = Path(args.input)
+    if not in_path.exists():
+        print(f"ERROR: input file not found: {in_path}", file=sys.stderr)
+        sys.exit(1)
+
+    # ── tokenizer ─────────────────────────────────────────────────────────────
+    print(f"Model / tokenizer  : {args.model}")
+    tokenizer = build_tokenizer(args.model, args.block_size, args.token)
+    block_size = tokenizer.model_max_length
+    print(f"Block size         : {block_size} tokens")
+    print(f"Vocab size (final) : {len(tokenizer)}")
+    print(f"EOS token          : {tokenizer.eos_token!r}  (id={tokenizer.eos_token_id})")
+    print()
+
+    # ── load ──────────────────────────────────────────────────────────────────
+    print(f"[1/4] Loading {in_path.resolve()} ...")
+    ds: Dataset = Dataset.from_parquet(str(in_path))
+    print(f"      {len(ds):,} records loaded")
+
+    # ── assemble text ─────────────────────────────────────────────────────────
+    print("\n[2/4] Assembling text column ...")
+    ds = ds.map(
+        _assemble_text_batch,
+        batched=True,
+        num_proc=args.num_workers,
+        remove_columns=ds.column_names,
+        desc="assemble",
+    )
+    before = len(ds)
+    ds = ds.filter(_is_valid, num_proc=args.num_workers, desc="filter-empty")
+    dropped = before - len(ds)
+    print(f"      {len(ds):,} records with text  ({dropped:,} dropped — empty/null fields)")
+
+    # ── tokenize ──────────────────────────────────────────────────────────────
+    print("\n[3/4] Tokenizing (no truncation, EOS appended) ...")
+    ds = ds.map(
+        _tokenize_batch,
+        fn_kwargs={"tokenizer": tokenizer},
+        batched=True,
+        batch_size=1_000,
+        writer_batch_size=500,
+        num_proc=args.num_workers,
+        remove_columns=["text"],
+        desc="tokenize",
+    )
+
+    # ── chunk ─────────────────────────────────────────────────────────────────
+    print(f"\n[4/4] Chunking into {block_size}-token blocks ...")
+    ds = ds.map(
+        _group_texts,
+        fn_kwargs={"block_size": block_size},
+        batched=True,
+        batch_size=_GROUP_BATCH_SIZE,
+        num_proc=args.num_workers,
+        desc="chunk",
+    )
+    total_tokens = len(ds) * block_size
+    print(f"      {len(ds):,} blocks  ({total_tokens:,} tokens)")
+    if len(ds) == 0:
+        print("ERROR: chunking produced 0 blocks. Check that --block-size is set "
+              "correctly and that the input dataset is non-empty.", file=sys.stderr)
+        sys.exit(1)
+    if "labels" not in ds.column_names:
+        ds = ds.add_column("labels", ds["input_ids"])
+
+    # ── optional validation split ─────────────────────────────────────────────
+    out_ds: Dataset | DatasetDict
+    if args.validation_split > 0.0:
+        split = ds.train_test_split(
+            test_size=args.validation_split, seed=42, shuffle=True
+        )
+        out_ds = DatasetDict({"train": split["train"], "validation": split["test"]})
+        print(
+            f"\n      train      : {len(split['train']):,} blocks"
+            f"\n      validation : {len(split['test']):,} blocks"
+        )
+    else:
+        out_ds = ds
+
+    # ── save ──────────────────────────────────────────────────────────────────
+    out_dir = Path(args.output)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    print(f"\nSaving parquet to {out_dir.resolve()} ...")
+
+    splits: dict[str, Dataset] = (
+        dict(out_ds.items()) if isinstance(out_ds, DatasetDict) else {"train": out_ds}
+    )
+    for split_name, split_ds in splits.items():
+        dest = out_dir / f"{split_name}.parquet"
+        split_ds.to_parquet(str(dest))
+        print(f"  Wrote {dest.name}  ({len(split_ds):,} blocks)")
+
+    if args.push_to_hub:
+        print(f"\nPushing to Hub: {args.push_to_hub} ...")
+        out_ds.push_to_hub(args.push_to_hub, token=args.token)
+        print("Pushed.")
+
+    # ── summary ───────────────────────────────────────────────────────────────
+    print()
+    print("=" * 60)
+    print("TOKENIZATION COMPLETE")
+    print("=" * 60)
+    for split_name, split_ds in splits.items():
+        print(
+            f"  {split_name:<12} {len(split_ds):>10,} blocks"
+            f"  ({len(split_ds) * block_size:,} tokens)"
+        )
+
+    schema_ds = next(iter(splits.values()))
+    print(f"\nDataset schema : {list(schema_ds.column_names)}")
+    print(f"Output         : {out_dir.resolve()}")
+    if args.push_to_hub:
+        print(f"Hub            : {args.push_to_hub}")
+    print()
+    print("Pass to continued_pretrain.py with:")
+    print(f"  --dataset_name {str(out_dir.resolve())!r}")
+
+
+if __name__ == "__main__":
+    main()

tokenized_dataset/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b11b25e97eb3c3b9cfa6feb778898f786a8af4236a19b69a9332688064bf43cb
+size 4598221447

tokenized_dataset/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0906df97b7a78fb6d346f45f2c607778ea0c6f08741030c54e0c1d20c51a98bd
+size 244075062

tokenized_dataset_msoft-bitnet-b1.58-2B-4T-bf16/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d22464ab9dbc4ef4400af541e49afbdb2272a101eef57ee162b34bdb1d3da913
+size 4535079215

tokenized_dataset_msoft-bitnet-b1.58-2B-4T-bf16/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3543a4b466780574ca548478e90d2d2f72f9201931242128e74732e7d15ec7d2
+size 239858591

tokenized_dataset_starcoderbase-1b_chunk1k/train.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e50e3b1b320dee68e539807fa3e74d75e7853523c691ec393e6179f0f986d15
+size 4585957794

tokenized_dataset_starcoderbase-1b_chunk1k/validation.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9cb0484c75a31235ce8871807c99cdbab0eb23e536a6791560e16df24823dc6
+size 241465412

upload_to_hub.py

@@ -0,0 +1,102 @@
+"""
+Upload the current repo to a fresh HuggingFace dataset via the Hub HTTP API.
+Uploads only git-tracked files — raw SLTrans language folders are ignored.
+
+Usage:
+    python upload_to_hub.py
+    python upload_to_hub.py --repo nlpscu/Multilingual-Code-Generator --private
+"""
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+from huggingface_hub import HfApi
+
+
+def git_tracked_files() -> list[str]:
+    result = subprocess.run(
+        ["git", "ls-files"],
+        capture_output=True, text=True, cwd=Path(__file__).parent,
+    )
+    if result.returncode != 0:
+        print("ERROR: not inside a git repo or git not found", file=sys.stderr)
+        sys.exit(1)
+    return [f for f in result.stdout.strip().splitlines() if f]
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--repo",    default="st-taro/csen346_temp",
+                    help="HuggingFace dataset repo id  (default: st-taro/csen346_temp)")
+    ap.add_argument("--private", action="store_true", default=False,
+                    help="Create as private repo (note: private repos have a 10 GB LFS limit)")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="Print files that would be uploaded without uploading")
+    args = ap.parse_args()
+
+    root = Path(__file__).parent
+    files = git_tracked_files()
+
+    print(f"Repo   : {args.repo}")
+    print(f"Private: {args.private}")
+    print(f"Files  : {len(files)}")
+    for f in files:
+        size = (root / f).stat().st_size if (root / f).exists() else 0
+        print(f"  {f}  ({size / 1e6:.1f} MB)")
+
+    if args.dry_run:
+        print("\nDry run — nothing uploaded.")
+        return
+
+    api = HfApi()
+
+    # Create repo (no-op if already exists)
+    try:
+        api.create_repo(
+            repo_id=args.repo,
+            repo_type="dataset",
+            private=args.private,
+            exist_ok=True,
+        )
+        print(f"\nRepo ready: https://huggingface.co/datasets/{args.repo}")
+    except Exception as e:
+        print(f"ERROR creating repo: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Upload files one at a time so progress is visible and failures are isolated
+    failed = []
+    for i, filepath in enumerate(files, 1):
+        local = root / filepath
+        if not local.exists():
+            print(f"[{i}/{len(files)}] SKIP (not on disk): {filepath}")
+            continue
+        size_mb = local.stat().st_size / 1e6
+        print(f"[{i}/{len(files)}] {filepath}  ({size_mb:.1f} MB) ... ", end="", flush=True)
+        try:
+            api.upload_file(
+                path_or_fileobj=str(local),
+                path_in_repo=filepath,
+                repo_id=args.repo,
+                repo_type="dataset",
+            )
+            print("done")
+        except Exception as e:
+            print(f"FAILED: {e}")
+            failed.append((filepath, str(e)))
+
+    print()
+    if failed:
+        print(f"Upload finished with {len(failed)} failure(s):")
+        for f, err in failed:
+            print(f"  {f}: {err}")
+        sys.exit(1)
+    else:
+        print(f"All {len(files)} files uploaded.")
+        print(f"Dataset: https://huggingface.co/datasets/{args.repo}")
+
+
+if __name__ == "__main__":
+    main()