Shard and parallelize HPLT filtering

.gitignore

@@ -0,0 +1,7 @@
+logs/
+data/common_corpus_pl/
+data/european_hplt_pl/
+data/european_hplt_pl_500m/
+data/european_hplt_pl_chunk_test*/
+data/european_hplt_pl_file_test/
+data/european_hplt_pl_parallel_500m*/

src/filter_european_hplt.py

@@ -189,11 +189,19 @@ def parse_args() -> argparse.Namespace:
     ap = argparse.ArgumentParser()
     ap.add_argument("--repo-id", default="ashtok897/european-hplt-v1")
     ap.add_argument("--split", default="train")
+    ap.add_argument(
+        "--data-files",
+        default="",
+        help="Optional comma-separated dataset files, e.g. data/train/train-00000-of-00181.parquet",
+    )
+    ap.add_argument("--hf-token-env", default="HF_TOKEN")
     ap.add_argument("--out-dir", type=Path, default=Path("data/european_hplt_pl"))
     ap.add_argument("--source-name", default=SOURCE_NAME)
     ap.add_argument("--max-records", type=int, default=100_000)
     ap.add_argument("--max-tokens", type=int, default=100_000_000)
     ap.add_argument("--batch-size", type=int, default=1000)
+    ap.add_argument("--shard-records", type=int, default=50_000)
+    ap.add_argument("--shard-tokens", type=int, default=50_000_000)
     ap.add_argument("--min-score", type=float, default=10.0)
     ap.add_argument("--min-lang-prob", type=float, default=0.80)
     ap.add_argument("--max-mt-prob", type=float, default=0.20)
@@ -218,12 +226,44 @@ def main() -> None:
     args.exclude_domain_contains = parse_csv(args.exclude_domain_contains)
     args.domain_counts = {}
     args.out_dir.mkdir(parents=True, exist_ok=True)
-    out_parquet = args.out_dir / f"{args.source_name}.parquet"
     out_stats = args.out_dir / f"{args.source_name}.stats.json"
     out_datasheet = args.out_dir / f"{args.source_name}.md"
 
-    ds = load_dataset(args.repo_id, split=args.split, streaming=True)
-    writer = None if args.dry_run else pq.ParquetWriter(out_parquet, SCHEMA, compression="zstd")
+    load_kwargs = {"split": args.split, "streaming": True}
+    if args.data_files:
+        load_kwargs["data_files"] = [item.strip() for item in args.data_files.split(",") if item.strip()]
+    hf_token = os.environ.get(args.hf_token_env) if args.hf_token_env else None
+    if hf_token:
+        load_kwargs["token"] = hf_token
+    ds = load_dataset(args.repo_id, **load_kwargs)
+    writer = None
+    shard_index = 0
+    shard_records = 0
+    shard_tokens = 0
+    shard_paths: list[str] = []
+
+    def open_writer() -> pq.ParquetWriter | None:
+        nonlocal shard_index
+        if args.dry_run:
+            return None
+        if args.shard_records > 0 or args.shard_tokens > 0:
+            path = args.out_dir / f"{args.source_name}-part-{shard_index:05d}.parquet"
+            shard_index += 1
+        else:
+            path = args.out_dir / f"{args.source_name}.parquet"
+        shard_paths.append(str(path))
+        print(f"opening shard: {path}", flush=True)
+        return pq.ParquetWriter(path, SCHEMA, compression="zstd")
+
+    def should_rotate() -> bool:
+        if args.dry_run or writer is None:
+            return False
+        if args.shard_records > 0 and shard_records >= args.shard_records:
+            return True
+        if args.shard_tokens > 0 and shard_tokens >= args.shard_tokens:
+            return True
+        return False
+
     stats = {
         "read": 0,
         "kept": 0,
@@ -280,10 +320,26 @@ def main() -> None:
 
             if len(batch) >= args.batch_size:
                 if writer:
-                    stats["tokens"] += write_batch(writer, batch, args.source_name)
+                    written_tokens = write_batch(writer, batch, args.source_name)
                 else:
-                    stats["tokens"] += sum(estimate_tokens(item[1]) for item in batch)
+                    if not args.dry_run:
+                        writer = open_writer()
+                        written_tokens = write_batch(writer, batch, args.source_name)
+                    else:
+                        written_tokens = sum(estimate_tokens(item[1]) for item in batch)
+                stats["tokens"] += written_tokens
+                shard_tokens += written_tokens
+                shard_records += len(batch)
                 batch.clear()
+                if should_rotate():
+                    writer.close()
+                    print(
+                        f"closed shard records={shard_records:,} tokens={shard_tokens:,}",
+                        flush=True,
+                    )
+                    writer = None
+                    shard_records = 0
+                    shard_tokens = 0
             if stats["kept"] >= args.max_records or stats["tokens"] >= args.max_tokens:
                 break
             if args.progress_every and stats["read"] % args.progress_every == 0:
@@ -295,14 +351,21 @@ def main() -> None:
     finally:
         if batch:
             if writer:
-                stats["tokens"] += write_batch(writer, batch, args.source_name)
+                written_tokens = write_batch(writer, batch, args.source_name)
             else:
-                stats["tokens"] += sum(estimate_tokens(item[1]) for item in batch)
+                if not args.dry_run:
+                    writer = open_writer()
+                    written_tokens = write_batch(writer, batch, args.source_name)
+                else:
+                    written_tokens = sum(estimate_tokens(item[1]) for item in batch)
+            stats["tokens"] += written_tokens
+            shard_tokens += written_tokens
+            shard_records += len(batch)
         if writer:
             writer.close()
 
     stats["secs"] = round(time.time() - t0, 1)
-    stats["out_parquet"] = None if args.dry_run else str(out_parquet)
+    stats["out_parquet"] = None if args.dry_run else shard_paths
     out_stats.write_text(json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
     out_datasheet.write_text(
         "\n".join(
@@ -331,7 +394,7 @@ def main() -> None:
     print(f"drops={stats['drop']}")
     print(f"wrote: {out_stats}")
     if not args.dry_run:
-        print(f"wrote: {out_parquet}")
+        print(f"wrote shards: {len(shard_paths)}")
     print(f"wrote: {out_datasheet}")
     sys.stdout.flush()
     os._exit(0)