Fan-out hardening from first production runs (16M rows embedded today)

- Zero-copy float32 Arrow shard writer: the old add_column([e.tolist()...])
materialized ~18GB of Python floats at 1.2M rows and swap-wedged workers
silently; also halves shard size (float32 fixed_size_list vs list<double>)
- Passthrough consolidator: per-file download->upload, peak disk = ONE shard
(34GB wiki merge in 293s on cpu-xl); normalizes old list<double> shards to
fixed_size_list<float32> so mixed-version runs still merge loadable
- --streaming: file-level IterableDataset sharding, each rank streams only its
own files, bounded-memory part writes (very-big-dataset mode; text only)
- Input revision pinned at launch and recorded in the manifest - every rank
and any later --retry-rank slices the identical snapshot
- 'writing' heartbeat state so post-encode is visible, not silent
- --consolidate-flavor; retry exit-code check; manifest-driven retries

Validated on Jobs: wikipedia-en 6,407,814 rows (8x l4x1) and fineweb-edu
sample-10BT 9,672,101 rows (8x l4x1, 56 min end-to-end); streaming smoke green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

README.md

@@ -58,9 +58,11 @@ Every shard is idempotent (a rank overwrites only its own files), so recovery is
 `--consolidate-only --run-id <id>` re-runs the merge. Each worker's timeout gives a **hard cost
 ceiling**: a fleet can never cost more than `N × flavor-rate × timeout`.
 
-Scale note: workers shard row-wise after loading the split, so each rank still downloads the full
-split first — fine up to a few tens of millions of rows; beyond that, shard at the file level or
-stream (planned follow-up).
+Scale note: by default workers shard row-wise after loading the split, so each rank downloads the
+full split first — fine up to a few tens of millions of rows. Past that, add `--streaming`: workers
+then shard at the **file** level and each rank streams only its own files (text only; needs
+`num_files ≥ num_shards`). The launcher pins the input dataset revision either way, so every rank
+— including a `--retry-rank` weeks later — slices the identical snapshot.
 
 ## Which model?
 

consolidate-shards.py

@@ -1,18 +1,25 @@
 # /// script
 # requires-python = ">=3.10"
 # dependencies = [
-#     "datasets",
 #     "huggingface-hub>=1.12",
+#     "pyarrow",
 # ]
 # ///
 """
-Merge the parquet shards of a fan-out embedding run (see launch-embedding-fleet.py)
-into the final Hub dataset, in one commit, with a provenance card.
+Assemble the parquet shards of a fan-out embedding run (see launch-embedding-fleet.py)
+into the final Hub dataset, one file at a time, with a provenance card.
 
-Reads runs/<run-id>/run.json from the run bucket, verifies all shards are present,
-downloads them, and pushes the concatenated dataset. Deliberately the ONLY step in
-the fleet that commits to a dataset repo — workers write bucket objects, so N-way
-commit contention (412s) can't happen by construction.
+Pass-through design: worker shards are ALREADY valid parquet in final order, so nothing
+is loaded or re-serialized — each file is downloaded, its footer row count read, and the
+file uploaded to the dataset repo as data/train-XXXXX-of-YYYYY.parquet. Peak disk = one
+shard, so any total run size fits on a small CPU flavor. Deliberately the ONLY step in
+the fleet that writes to a dataset repo — workers write bucket objects, so N-way commit
+contention (412s) can't happen by construction.
+
+Accepts both worker output namings: <rank>.parquet (row mode) and <rank>.partNNNN.parquet
+(streaming mode). Re-running is idempotent for same-named files; if a re-run has FEWER
+files than a previous consolidation of the same repo, stale data/ files from the earlier
+attempt are removed first.
 
 Usually spawned as a cpu Job by the launcher; can also run locally:
     uv run consolidate-shards.py --bucket you/embedding-runs --run-id 20260709-1200-abc123
@@ -21,6 +28,7 @@ import argparse
 import json
 import logging
 import os
+import re
 import sys
 import tempfile
 import time
@@ -30,6 +38,54 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(mess
 logger = logging.getLogger("consolidate-shards")
 
 
+def normalize_embeddings_column(local, out_col):
+    """Rewrite the file in place if its embeddings column isn't fixed_size_list<float32>.
+
+    Shards written by different script versions can disagree (old: list<double>, new:
+    fixed_size_list<float32>); a repo with mixed parquet schemas breaks load_dataset, so
+    the consolidator is the place to unify. Returns the file's row count."""
+    import pyarrow as pa
+    import pyarrow.compute as pc
+    import pyarrow.parquet as pq
+    pf = pq.ParquetFile(local)
+    schema = pf.schema_arrow
+    if out_col not in schema.names:
+        return pf.metadata.num_rows  # nothing to normalize (unexpected, but not fatal here)
+    field = schema.field(out_col)
+    if pa.types.is_fixed_size_list(field.type) and field.type.value_type == pa.float32():
+        return pf.metadata.num_rows
+    t = pq.read_table(local)
+    col = t[out_col].combine_chunks()
+    dim = len(col[0].as_py())
+    values = pc.cast(pc.list_flatten(col), pa.float32())
+    fixed = pa.FixedSizeListArray.from_arrays(values, dim)
+    idx = t.schema.get_field_index(out_col)
+    t = t.set_column(idx, pa.field(out_col, fixed.type), fixed)
+    logger.info(f"  normalized {Path(local).name}: {field.type} → {fixed.type}")
+    pq.write_table(t, local)
+    return t.num_rows
+
+
+def upload_with_retry(api, local, repo_id, path_in_repo, max_retries=3):
+    for attempt in range(1, max_retries + 1):
+        try:
+            if attempt > 1:
+                logger.warning("Disabling XET (fallback to HTTP upload)")
+                os.environ["HF_HUB_DISABLE_XET"] = "1"
+            api.upload_file(path_or_fileobj=local, path_in_repo=path_in_repo,
+                            repo_id=repo_id, repo_type="dataset")
+            return
+        except Exception as e:
+            logger.error(f"Upload attempt {attempt}/{max_retries} for {path_in_repo} failed: {e}")
+            if attempt < max_retries:
+                delay = 30 * (2 ** (attempt - 1))
+                logger.info(f"Retrying in {delay}s...")
+                time.sleep(delay)
+            else:
+                logger.error("All upload attempts failed. Shards remain in the bucket — re-run consolidation.")
+                sys.exit(1)
+
+
 def main():
     p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     p.add_argument("--bucket", required=True, help="Run bucket, e.g. you/embedding-runs")
@@ -37,12 +93,14 @@ def main():
     p.add_argument("--private", action="store_true")
     args = p.parse_args()
 
-    from datasets import load_dataset
-    from huggingface_hub import DatasetCard, download_bucket_files, list_bucket_tree, login
+    import pyarrow.parquet as pq
+    from huggingface_hub import (DatasetCard, HfApi, download_bucket_files,
+                                 list_bucket_tree, login)
 
     token = os.environ.get("HF_TOKEN")
     if token:
         login(token=token)
+    api = HfApi()
 
     prefix = f"runs/{args.run_id}"
     workdir = Path(tempfile.mkdtemp(prefix=f"consolidate-{args.run_id}-"))
@@ -53,27 +111,61 @@ def main():
     n = run["num_shards"]
     out_repo = run["output_dataset"]
 
-    shard_paths = sorted(
-        f.path for f in list_bucket_tree(args.bucket, prefix=f"{prefix}/data/", recursive=True)
-        if getattr(f, "path", "").endswith(".parquet")
-    )
-    expected = [f"{prefix}/data/{i:05d}.parquet" for i in range(n)]
-    missing = sorted(set(expected) - set(shard_paths))
+    # Collect shard files: <rank>.parquet (row mode) or <rank>.partNNNN.parquet (streaming).
+    pat = re.compile(r"^(\d{5})(?:\.part(\d{4}))?\.parquet$")
+    shard_files = []  # (rank, part, bucket_path)
+    for f in list_bucket_tree(args.bucket, prefix=f"{prefix}/data/", recursive=True):
+        name = Path(getattr(f, "path", "")).name
+        m = pat.match(name)
+        if m:
+            shard_files.append((int(m.group(1)), int(m.group(2) or 0), f.path))
+    shard_files.sort()
+    ranks_present = {r for r, _, _ in shard_files}
+    missing = sorted(set(range(n)) - ranks_present)
     if missing:
-        logger.error(f"Missing {len(missing)}/{n} shard(s): {missing}")
+        logger.error(f"Missing output from {len(missing)}/{n} rank(s): {missing}")
         logger.error("Re-run those ranks (launch-embedding-fleet.py --retry-rank), then consolidate again.")
         sys.exit(1)
+    total_files = len(shard_files)
+    logger.info(f"{total_files} shard file(s) across {n} rank(s)")
 
-    logger.info(f"Downloading {n} shards from {args.bucket}/{prefix}/data/")
-    local = [(path, workdir / Path(path).name) for path in expected]
-    download_bucket_files(args.bucket, local, raise_on_missing_files=True)
-
-    ds = load_dataset("parquet", data_files=[str(dst) for _, dst in local], split="train")
-    logger.info(f"Merged {n} shards → {len(ds):,} rows (manifest says {run['rows_total']:,})")
-    if run.get("rows_total") and len(ds) != run["rows_total"]:
-        logger.warning("Row count differs from manifest — check for a re-run with different --max-samples.")
+    private = args.private or run.get("private", False)
+    api.create_repo(out_repo, repo_type="dataset", private=private, exist_ok=True)
 
-    # Read final worker statuses for the card's timing/throughput line (best effort).
+    # Remove stale data/ files from any earlier consolidation with a different file count.
+    expected = {f"data/train-{i:05d}-of-{total_files:05d}.parquet" for i in range(total_files)}
+    try:
+        existing = [f for f in api.list_repo_files(out_repo, repo_type="dataset")
+                    if f.startswith("data/") and f.endswith(".parquet") and f not in expected]
+        for stale in existing:
+            logger.warning(f"Deleting stale {stale} from a previous consolidation")
+            api.delete_file(stale, repo_id=out_repo, repo_type="dataset")
+    except Exception as e:
+        logger.warning(f"stale-file check skipped: {e}")
+
+    # Embedding column name: default unless overridden via the run's embed_args.
+    ea = run.get("embed_args") or []
+    out_col = ea[ea.index("--output-column") + 1] if "--output-column" in ea else "embeddings"
+
+    # Pass each file through: download → normalize schema if needed → upload → delete local.
+    rows_total = 0
+    t0 = time.time()
+    for seq, (rank, part, bucket_path) in enumerate(shard_files):
+        local = workdir / Path(bucket_path).name
+        download_bucket_files(args.bucket, [(bucket_path, local)], raise_on_missing_files=True)
+        rows = normalize_embeddings_column(local, out_col)
+        rows_total += rows
+        dest = f"data/train-{seq:05d}-of-{total_files:05d}.parquet"
+        logger.info(f"[{seq + 1}/{total_files}] rank {rank} part {part}: {rows:,} rows → {dest}")
+        upload_with_retry(api, local, out_repo, dest)
+        local.unlink()
+
+    logger.info(f"Assembled {rows_total:,} rows in {time.time() - t0:.0f}s "
+                f"(manifest says {run.get('rows_total')})")
+    if run.get("rows_total") and rows_total != run["rows_total"]:
+        logger.warning("Row count differs from manifest — check for a re-run with different settings.")
+
+    # Timing/throughput line from final worker statuses (best effort).
     stats_line = ""
     try:
         status_files = [(f"{prefix}/status/{i:05d}.json", workdir / f"status-{i:05d}.json") for i in range(n)]
@@ -92,15 +184,18 @@ def main():
     origin = ("Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)"
               if on_jobs else "Generated")
     jobs_tag = "\n- hf-jobs" if on_jobs else ""
+    mode = "streaming file-shards" if run.get("streaming") else "row shards"
+    rev_line = f"- Input revision: `{run['revision']}`\n" if run.get("revision") else ""
     job_list = "".join(f"  - shard {i}: `{jid}`\n" for i, jid in enumerate(run.get("job_ids", [])))
     card = DatasetCard(
         f"---\ntags:\n- embeddings\n- uv-script\n- generated{jobs_tag}\n---\n\n"
         f"# {out_repo}\n\n"
         f"Embeddings of [`{run['input_dataset']}`](https://huggingface.co/datasets/{run['input_dataset']}) "
-        f"column `{run['column']}`, computed by a fleet of {n} parallel Jobs.\n\n"
+        f"column `{run['column']}`, computed by a fleet of {n} parallel Jobs ({mode}).\n\n"
         f"- Model: [`{run['model']}`](https://huggingface.co/{run['model']})\n"
+        f"- Rows: {rows_total:,}\n"
         f"- Fleet: {n} × `{run['flavor']}` · run `{run['run_id']}`\n"
-        f"{stats_line}"
+        f"{rev_line}{stats_line}"
         f"- Worker jobs:\n{job_list}\n"
         f"## Reproduction\n\n"
         f"{origin} with the [`generate-embeddings.py`]({script_url}) recipe from "
@@ -110,28 +205,6 @@ def main():
         f"    {run['input_dataset']} <output-dataset> --column {run['column']} "
         f"--model {run['model']} --num-shards {n} --flavor {run['flavor']}\n```\n"
     )
-
-    # Same retry + XET-disable fallback as generate-embeddings.py: a transient upload
-    # failure here would waste the whole fleet's (paid) work.
-    private = args.private or run.get("private", False)
-    logger.info(f"Pushing to {out_repo} (private={private})")
-    max_retries = 3
-    for attempt in range(1, max_retries + 1):
-        try:
-            if attempt > 1:
-                logger.warning("Disabling XET (fallback to HTTP upload)")
-                os.environ["HF_HUB_DISABLE_XET"] = "1"
-            ds.push_to_hub(out_repo, private=private)
-            break
-        except Exception as e:
-            logger.error(f"Upload attempt {attempt}/{max_retries} failed: {e}")
-            if attempt < max_retries:
-                delay = 30 * (2 ** (attempt - 1))
-                logger.info(f"Retrying in {delay}s...")
-                time.sleep(delay)
-            else:
-                logger.error("All upload attempts failed. Shards remain in the bucket — re-run consolidation.")
-                sys.exit(1)
     try:
         card.push_to_hub(out_repo, repo_type="dataset")
     except Exception as e:

generate-embeddings.py

@@ -271,6 +271,100 @@ class StatusReporter:
             logger.warning(f"status write skipped ({e})")
 
 
+def run_streaming_shard(ds, model, prompt_str, args):
+    """Streaming fan-out worker: iterate this rank's FILE-shard, encode in chunks, and flush
+    parquet PARTS to the bucket every ~250k rows, so memory and disk stay bounded no matter
+    how big the shard is. Output keys: runs/<run-id>/data/<rank>.part<p>.parquet — the
+    consolidator accepts both this and row mode's single <rank>.parquet naming."""
+    import itertools
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    encode_fn = model.encode_query if args.query_mode else model.encode_document
+    encode_kwargs = {"prompt": prompt_str} if prompt_str is not None else {}
+
+    def clean(t):
+        return t if isinstance(t, str) and t.strip() else " "
+
+    # Buffer a head sample for token sniffing + the auto-batch probe, then chain it back.
+    it = iter(ds)
+    head = list(itertools.islice(it, 1024))
+    if not head:
+        logger.error(f"File-shard {args.shard_index} yielded no rows.")
+        sys.exit(1)
+    if args.column not in head[0]:
+        logger.error(f"Column {args.column!r} not in rows. Available: {sorted(head[0])}")
+        sys.exit(1)
+    if args.output_column in head[0]:
+        logger.error(f"Output column {args.output_column!r} already exists — choose another --output-column.")
+        sys.exit(1)
+    head_texts = [clean(r[args.column]) for r in head]
+    median_tok = sniff_token_lengths(model, head_texts, args.max_seq_len)
+    if str(args.batch_size).lower() == "auto":
+        if median_tok is None or median_tok >= 256:
+            candidates = (32, 64, 128, 256)
+        elif median_tok >= 64:
+            candidates = (64, 128, 256, 512)
+        else:
+            candidates = (128, 256, 512, 1024)
+        batch_size = find_batch_size(model, head_texts, args.normalize, candidates=candidates)
+    else:
+        batch_size = int(args.batch_size)
+
+    reporter = StatusReporter(args.output_bucket, args.run_id, args.shard_index,
+                              rows_total=None, tokens_per_row=median_tok)
+    reporter.report(0, force=True)
+
+    chunk_rows, part_rows = 25_000, 250_000
+    prog = {"part_idx": 0, "rows_done": 0}
+    buf_rows, buf_texts, part_buf = [], [], []
+
+    def flush_part():
+        if not part_buf:
+            return
+        path = f"/tmp/part-{args.shard_index:05d}-{prog['part_idx']:04d}.parquet"
+        pq.write_table(pa.Table.from_pylist(part_buf), path)
+        dest = f"runs/{args.run_id}/data/{args.shard_index:05d}.part{prog['part_idx']:04d}.parquet"
+        logger.info(f"Uploading {len(part_buf):,}-row part → {args.output_bucket}/{dest}")
+        put_bucket_files(args.output_bucket, [(path, dest)])
+        os.remove(path)
+        part_buf.clear()
+        prog["part_idx"] += 1
+
+    def encode_chunk():
+        if not buf_rows:
+            return
+        emb = encode_fn(buf_texts, batch_size=batch_size, show_progress_bar=False,
+                        convert_to_numpy=True, normalize_embeddings=args.normalize, **encode_kwargs)
+        for r, e in zip(buf_rows, emb):
+            r[args.output_column] = e.tolist()
+        part_buf.extend(buf_rows)
+        prog["rows_done"] += len(buf_rows)
+        buf_rows.clear()
+        buf_texts.clear()
+        reporter.report(prog["rows_done"])
+        if len(part_buf) >= part_rows:
+            flush_part()
+
+    t0 = time.perf_counter()
+    try:
+        for row in itertools.chain(head, it):
+            buf_rows.append(dict(row))
+            buf_texts.append(clean(row[args.column]))
+            if len(buf_rows) >= chunk_rows:
+                encode_chunk()
+        encode_chunk()
+        flush_part()
+    except Exception:
+        reporter.report(state="error", force=True)
+        raise
+    secs = time.perf_counter() - t0
+    logger.info(f"Embedded {prog['rows_done']:,} rows in {secs:.0f}s "
+                f"({prog['rows_done'] / max(secs, 1e-6):.0f} rows/s), {prog['part_idx']} part(s)")
+    reporter.report(prog["rows_done"], state="done", force=True)
+    logger.info(f"✅ streaming shard {args.shard_index + 1}/{args.num_shards} of run {args.run_id} uploaded")
+
+
 def main():
     p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     p.add_argument("input_dataset", help="Input dataset ID on the Hugging Face Hub")
@@ -310,6 +404,14 @@ def main():
                    help="Fan-out: bucket for shard parquets + status (env OUTPUT_BUCKET).")
     p.add_argument("--run-id", default=os.environ.get("RUN_ID"),
                    help="Fan-out: run identifier grouping shards under runs/<run-id>/ (env RUN_ID).")
+    p.add_argument("--streaming", action="store_true",
+                   default=os.environ.get("STREAMING") == "1",
+                   help="Fan-out: stream the dataset and shard at the FILE level (env STREAMING=1). "
+                        "Each rank downloads only its own files — use for very big datasets. "
+                        "Text modality only; incompatible with --max-samples.")
+    p.add_argument("--revision", default=os.environ.get("REVISION"),
+                   help="Input dataset revision (commit sha). Pin this in fan-out runs so every "
+                        "rank slices the identical snapshot (env REVISION).")
     args = p.parse_args()
 
     def int_or_error(val, name):
@@ -335,6 +437,14 @@ def main():
     elif args.shard_index is not None:
         p.error("--shard-index requires --num-shards.")
 
+    if args.streaming:
+        if not sharded:
+            p.error("--streaming is a fan-out mode — it needs --num-shards/--shard-index.")
+        if args.modality != "text":
+            p.error("--streaming currently supports text modality only.")
+        if args.max_samples:
+            p.error("--max-samples is incompatible with --streaming (use row mode for capped test runs).")
+
     import torch
     from datasets import load_dataset
     from huggingface_hub import DatasetCard, login
@@ -346,18 +456,35 @@ def main():
     if not torch.cuda.is_available():
         logger.warning("No CUDA — running on CPU (much slower). Prefer a GPU flavor, e.g. --flavor l4x1.")
 
-    logger.info(f"Loading {args.input_dataset} [{args.split}]")
-    ds = (load_dataset(args.input_dataset, args.config, split=args.split) if args.config
-          else load_dataset(args.input_dataset, split=args.split))
-    if args.column not in ds.column_names:
-        logger.error(f"Column {args.column!r} not found. Available: {ds.column_names}")
-        sys.exit(1)
-    if args.output_column in ds.column_names:
-        logger.error(f"Output column {args.output_column!r} already exists — choose another --output-column.")
-        sys.exit(1)
-    if args.max_samples:
+    logger.info(f"Loading {args.input_dataset} [{args.split}]"
+                + (f" @ {args.revision[:12]}" if args.revision else "")
+                + (" (streaming)" if args.streaming else ""))
+    load_kwargs = {"split": args.split, "streaming": args.streaming}
+    if args.revision:
+        load_kwargs["revision"] = args.revision
+    ds = (load_dataset(args.input_dataset, args.config, **load_kwargs) if args.config
+          else load_dataset(args.input_dataset, **load_kwargs))
+    if ds.column_names is not None:
+        if args.column not in ds.column_names:
+            logger.error(f"Column {args.column!r} not found. Available: {ds.column_names}")
+            sys.exit(1)
+        if args.output_column in ds.column_names:
+            logger.error(f"Output column {args.output_column!r} already exists — choose another --output-column.")
+            sys.exit(1)
+    if args.max_samples and not args.streaming:
         ds = ds.select(range(min(args.max_samples, len(ds))))
-    if sharded:
+    if sharded and args.streaming:
+        # File-level split: each rank reads ONLY its own data files. Sizes vary per rank and
+        # rows_total is unknown upfront; correctness (exact, deterministic, idempotent) holds
+        # as long as every rank pins the same --revision.
+        if ds.n_shards < args.num_shards:
+            logger.error(f"Dataset has {ds.n_shards} file shard(s) < --num-shards {args.num_shards}. "
+                         f"Lower --num-shards or use row mode.")
+            sys.exit(1)
+        ds = ds.shard(num_shards=args.num_shards, index=args.shard_index)
+        logger.info(f"Fan-out file-shard {args.shard_index + 1}/{args.num_shards} of run {args.run_id} "
+                    f"({ds.n_shards} file(s) for this rank)")
+    elif sharded:
         # Contiguous slices keep row order reconstructable at consolidation. Note the whole
         # split was still downloaded above — acceptable at few-M rows, not at corpus scale.
         ds = ds.shard(num_shards=args.num_shards, index=args.shard_index, contiguous=True)
@@ -366,7 +493,8 @@ def main():
             logger.error(f"Shard {args.shard_index} is empty — num_shards exceeds the row count. "
                          f"Lower --num-shards (or raise --max-samples).")
             sys.exit(1)
-    logger.info(f"{len(ds)} rows; modality={args.modality}")
+    if not args.streaming:
+        logger.info(f"{len(ds)} rows; modality={args.modality}")
 
     device = "cuda" if torch.cuda.is_available() else "cpu"
     model = SentenceTransformer(args.model, device=device, trust_remote_code=True)
@@ -379,6 +507,9 @@ def main():
     prompt_str = None  # None = let encode_query/encode_document choose natively
     if args.modality == "text":
         prompt_str = resolve_prompt(model, args.model, is_query=args.query_mode, args=args)
+        if args.streaming:
+            run_streaming_shard(ds, model, prompt_str, args)
+            return
         items = [t if isinstance(t, str) and t.strip() else " " for t in ds[args.column]]
     else:
         if args.prompt or args.prompt_name:
@@ -443,15 +574,24 @@ def main():
     secs = time.perf_counter() - t0
     logger.info(f"Embedded {len(items)} in {secs:.1f}s ({len(items)/secs:.0f} rows/s), dim={dim}")
 
-    ds = ds.add_column(args.output_column, [e.tolist() for e in emb])
-
     if sharded:
         # Shard mode: no repo commit here (N workers committing → 412 contention). Write this
         # rank's parquet to the run bucket; consolidate-shards.py makes the single final commit.
-        out_path = f"/tmp/shard-{args.shard_index:05d}.parquet"
-        dest = f"runs/{args.run_id}/data/{args.shard_index:05d}.parquet"
+        #
+        # Build the embedding column as zero-copy float32 Arrow — NEVER as Python floats.
+        # `[e.tolist() for e in emb]` on an 800k-row shard is ~10 GB of PyFloat objects and
+        # swap-thrashed L4 workers into multi-hour silent stalls (wiki fleet, 2026-07-09).
+        import numpy as np
+        import pyarrow as pa
+        import pyarrow.parquet as pq
+        reporter.report(len(items), state="writing", force=True)
         try:
-            ds.to_parquet(out_path)
+            emb32 = np.ascontiguousarray(emb, dtype=np.float32)
+            emb_col = pa.FixedSizeListArray.from_arrays(pa.array(emb32.ravel()), emb32.shape[1])
+            table = ds.with_format("arrow")[:].append_column(args.output_column, emb_col)
+            out_path = f"/tmp/shard-{args.shard_index:05d}.parquet"
+            dest = f"runs/{args.run_id}/data/{args.shard_index:05d}.parquet"
+            pq.write_table(table, out_path)
             logger.info(f"Uploading shard parquet → {args.output_bucket}/{dest}")
             put_bucket_files(args.output_bucket, [(out_path, dest)])
         except Exception:
@@ -461,6 +601,8 @@ def main():
         logger.info(f"✅ shard {args.shard_index + 1}/{args.num_shards} of run {args.run_id} uploaded")
         return
 
+    ds = ds.add_column(args.output_column, [e.tolist() for e in emb])
+
     # For the card: record the effective prefix (explicit, else the model's registered one).
     side_keys = ("query",) if args.query_mode else ("document", "passage", "corpus")
     effective = prompt_str if prompt_str is not None else next(

launch-embedding-fleet.py

@@ -97,6 +97,9 @@ def main():
                         "(1 TB) when total shard size approaches ~20 GB.")
     p.add_argument("--rows-total", type=int, default=None,
                    help="Override when the dataset has no split metadata")
+    p.add_argument("--streaming", action="store_true",
+                   help="Workers stream + shard at the FILE level (no full-split download per "
+                        "rank) — for very big datasets. Text only; incompatible with --max-samples.")
     p.add_argument("--private", action="store_true", help="Final output dataset is private")
     p.add_argument("--embed-args", nargs=argparse.REMAINDER, default=[],
                    help="Everything after --embed-args is passed through to generate-embeddings.py "
@@ -123,6 +126,8 @@ def main():
         p.error("--retry-rank / --consolidate-only need --run-id")
     if args.num_shards < 1:
         p.error(f"--num-shards must be >= 1 (got {args.num_shards})")
+    if args.streaming and args.max_samples:
+        p.error("--streaming is incompatible with --max-samples (use row mode for capped tests)")
 
     def read_manifest(run_id):
         import tempfile
@@ -144,17 +149,22 @@ def main():
         if manifest.get("max_samples"):
             script_args += ["--max-samples", str(manifest["max_samples"])]
         script_args += list(manifest.get("embed_args") or [])
+        env = {
+            "RANK": str(rank),
+            "NUM_SHARDS": str(manifest["num_shards"]),
+            "RUN_ID": manifest["run_id"],
+            "OUTPUT_BUCKET": bucket,
+        }
+        if manifest.get("revision"):
+            env["REVISION"] = manifest["revision"]
+        if manifest.get("streaming"):
+            env["STREAMING"] = "1"
         job = run_uv_job(
             args.script,
             script_args=script_args,
             flavor=manifest["flavor"],
             timeout=manifest["timeout"],
-            env={
-                "RANK": str(rank),
-                "NUM_SHARDS": str(manifest["num_shards"]),
-                "RUN_ID": manifest["run_id"],
-                "OUTPUT_BUCKET": bucket,
-            },
+            env=env,
             secrets={"HF_TOKEN": token},
             labels={"embedding-fleet-run": manifest["run_id"], "rank": str(rank)},
             token=token,
@@ -200,13 +210,20 @@ def main():
 
     # --- fresh run ---
     rows_total = args.rows_total or rows_in_split(args.input_dataset, args.config, args.split)
-    if rows_total is None:
+    if rows_total is None and not args.streaming:
         p.error("Couldn't determine the split's row count — pass --rows-total.")
-    if args.max_samples:
-        rows_total = min(rows_total, args.max_samples)
-    if args.num_shards > rows_total:
-        p.error(f"--num-shards {args.num_shards} exceeds the row count ({rows_total}) — "
-                f"some shards would be empty.")
+    if rows_total is not None:
+        if args.max_samples:
+            rows_total = min(rows_total, args.max_samples)
+        if not args.streaming and args.num_shards > rows_total:
+            p.error(f"--num-shards {args.num_shards} exceeds the row count ({rows_total}) — "
+                    f"some shards would be empty.")
+
+    # Pin the input snapshot: every rank (and any later --retry-rank) must slice the IDENTICAL
+    # revision, or a mid-run commit to the input dataset silently breaks the exact partition.
+    from huggingface_hub import dataset_info
+    revision = dataset_info(args.input_dataset, token=token).sha
+    logger.info(f"Pinned input revision: {revision[:12]}")
 
     run_id = time.strftime("%Y%m%d-%H%M%S") + "-" + pysecrets.token_hex(3)
     create_bucket(bucket, private=True, exist_ok=True, token=token)
@@ -226,12 +243,18 @@ def main():
         "timeout": args.timeout,
         "private": args.private,
         "embed_args": list(args.embed_args),
+        "streaming": args.streaming,
+        "revision": revision,
         "started_at": time.time(),
         "job_ids": [],
     }
     put_json(bucket, f"runs/{run_id}/run.json", manifest, token=token)
-    logger.info(f"Run {run_id}: {rows_total:,} rows → {args.num_shards} shards "
-                f"(~{rows_total // args.num_shards:,} rows each) on {args.flavor}")
+    if rows_total is not None:
+        logger.info(f"Run {run_id}: {rows_total:,} rows → {args.num_shards} shards "
+                    f"(~{rows_total // args.num_shards:,} rows each) on {args.flavor}")
+    else:
+        logger.info(f"Run {run_id}: streaming file-shards × {args.num_shards} on {args.flavor} "
+                    f"(row count unknown upfront)")
 
     jobs = [spawn_worker(rank, manifest) for rank in range(args.num_shards)]
     manifest["job_ids"] = [j.id for j in jobs]