Add --resume: one command converges any fan-out run

README.md

@@ -53,10 +53,20 @@ uv run https://huggingface.co/datasets/uv-scripts/embeddings/raw/main/launch-emb
   your-name/corpus your-name/corpus-embeddings --num-shards 8 --flavor l4x1 --timeout 1h
 ```
 
-Every shard is idempotent (a rank overwrites only its own files), so recovery is trivial:
-`--retry-rank 3 --run-id <id>` re-runs one failed shard with the run's original config,
-`--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`.
+Every shard is idempotent (a rank overwrites only its own files), so failures never cost you the
+run. Workers that fail are auto-retried once; past that, one command converges any run — no need
+to know which rank failed or why:
+
+```bash
+uv run launch-embedding-fleet.py <in> <out> --run-id <id> --resume   # re-runs ONLY missing shards, then merges
+```
+
+(`--retry-rank`/`--consolidate-only` remain for surgical control.) Each worker's timeout gives a
+**hard cost ceiling**: a fleet can never cost more than `N × flavor-rate × timeout`.
+
+Watch a run live — progress, ETA, live ~$ vs ceiling, GPU utilization, replica health — in the
+[fleet dashboard Space](https://huggingface.co/spaces/davanstrien/embedding-fleet-dashboard)
+(the launcher prints your run's deep link).
 
 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

launch-embedding-fleet.py

@@ -104,7 +104,10 @@ def main():
     p.add_argument("--embed-args", nargs=argparse.REMAINDER, default=[],
                    help="Everything after --embed-args is passed through to generate-embeddings.py "
                         "verbatim — put it LAST (any launcher flags after it are swallowed too).")
-    p.add_argument("--run-id", default=None, help="Attach to an existing run (with --retry-rank/--consolidate-only)")
+    p.add_argument("--run-id", default=None, help="Attach to an existing run (with --resume/--retry-rank/--consolidate-only)")
+    p.add_argument("--resume", action="store_true",
+                   help="Converge an existing --run-id: find ranks without a 'done' status, re-run "
+                        "exactly those, then consolidate. Idempotent — safe to run repeatedly.")
     p.add_argument("--retry-rank", type=int, default=None, help="Re-spawn a single failed shard of --run-id")
     p.add_argument("--consolidate-only", action="store_true", help="Just run consolidation for --run-id")
     p.add_argument("--no-wait", action="store_true",
@@ -122,8 +125,8 @@ def main():
     namespace = whoami(token=token)["name"]
     bucket = args.bucket or f"{namespace}/embedding-runs"
 
-    if (args.retry_rank is not None or args.consolidate_only) and not args.run_id:
-        p.error("--retry-rank / --consolidate-only need --run-id")
+    if (args.retry_rank is not None or args.consolidate_only or args.resume) and not args.run_id:
+        p.error("--resume / --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:
@@ -188,7 +191,67 @@ def main():
                     f"merges shards → {args.output_dataset}")
         return job
 
+    def execute_workers(ranks, manifest):
+        """Spawn the given ranks, wait, auto-retry failures ONCE, return still-failed ranks."""
+        for attempt in (1, 2):
+            jobs = {rank: spawn_worker(rank, manifest) for rank in ranks}
+            infos = wait_for_job([j.id for j in jobs.values()], token=token)
+            ranks = [rank for (rank, job), info in zip(jobs.items(), infos)
+                     if info.status.stage != JobStage.COMPLETED]
+            if not ranks:
+                return []
+            if attempt == 1:
+                logger.warning(f"{len(ranks)} worker(s) failed; auto-retrying once: {ranks}")
+        return ranks
+
+    def done_ranks(run_id, n):
+        """Ranks whose bucket status reports state == 'done' (works for both shard modes)."""
+        import tempfile
+        from pathlib import Path
+        done = set()
+        with tempfile.TemporaryDirectory() as td:
+            pairs = [(f"runs/{run_id}/status/{i:05d}.json", Path(td) / f"{i}.json") for i in range(n)]
+            download_bucket_files(bucket, pairs, token=token)
+            for i, (_, dst) in enumerate(pairs):
+                if dst.exists() and json.loads(dst.read_text()).get("state") == "done":
+                    done.add(i)
+        return done
+
     # --- attach-to-existing-run paths ---
+    if args.resume:
+        manifest = read_manifest(args.run_id)
+        n = manifest["num_shards"]
+        # Don't double-spawn ranks that are still running — wait for them, then diff.
+        from huggingface_hub import list_jobs
+        try:
+            in_flight = [j for j in list_jobs(labels={"embedding-fleet-run": args.run_id},
+                                              namespace=namespace, token=token)
+                         if j.status.stage in (JobStage.RUNNING, JobStage.SCHEDULING)
+                         and (j.labels or {}).get("rank") is not None]
+        except Exception as e:
+            logger.warning(f"in-flight check skipped ({e})")
+            in_flight = []
+        if in_flight:
+            ranks = sorted({j.labels["rank"] for j in in_flight})
+            logger.info(f"{len(in_flight)} worker(s) still in flight (ranks {ranks}) — waiting before resuming.")
+            wait_for_job([j.id for j in in_flight], token=token)
+        todo = sorted(set(range(n)) - done_ranks(args.run_id, n))
+        if todo:
+            logger.info(f"Resume {args.run_id}: {n - len(todo)}/{n} shards done; re-running {todo}")
+            still_failed = execute_workers(todo, manifest)
+            if still_failed:
+                logger.error(f"Ranks still failing after retry: {still_failed} — investigate, then --resume again.")
+                sys.exit(1)
+        else:
+            logger.info(f"Resume {args.run_id}: all {n} shards already done — consolidating.")
+        job = spawn_consolidator(args.run_id)
+        info = wait_for_job(job.id, token=token)
+        if info.status.stage != JobStage.COMPLETED:
+            logger.error(f"Consolidation failed (job {job.id}); run --resume again.")
+            sys.exit(1)
+        logger.info(f"✅ https://huggingface.co/datasets/{manifest['output_dataset']}")
+        return
+
     if args.retry_rank is not None:
         manifest = read_manifest(args.run_id)
         if not 0 <= args.retry_rank < manifest["num_shards"]:
@@ -269,12 +332,16 @@ def main():
 
     logger.info("Waiting for workers…")
     infos = wait_for_job([j.id for j in jobs], token=token)
-    failed = [(rank, j.id) for rank, (j, i) in enumerate(zip(jobs, infos))
+    failed = [rank for rank, (j, i) in enumerate(zip(jobs, infos))
               if i.status.stage != JobStage.COMPLETED]
     if failed:
-        logger.error(f"{len(failed)} worker(s) did not complete: {failed}")
-        logger.error(f"Re-run each with --run-id {run_id} --retry-rank <rank>, then --consolidate-only.")
-        sys.exit(1)
+        logger.warning(f"{len(failed)} worker(s) did not complete; auto-retrying: {failed}")
+        still_failed = execute_workers(failed, manifest)
+        if still_failed:
+            logger.error(f"Ranks still failing after retries: {still_failed}")
+            logger.error(f"Investigate (job logs / heartbeat age), then converge with: "
+                         f"--run-id {run_id} --resume")
+            sys.exit(1)
 
     job = spawn_consolidator(run_id)
     info = wait_for_job(job.id, token=token)