| """シャード単位のクレンジングパイプライン（本実行用）。 |
| |
| 1ファイル（parquet）ごとに次を行う。 |
| |
| 1. 有害コンテンツフィルタ（ワードリスト・ドメインブロックリスト・近接共起規則） |
| 2. 保持分に PII 置換 |
| 3. クリーン済み parquet と監査ファイル（removed.jsonl, audit.jsonl 等）を |
| ``<output-root>/<シャード名>/`` に書き出し、``shard_summary.json`` にまとめる |
| 4. 任意で HF データセットへバッチアップロード（``--upload-repo``）。アップロード後に |
| ローカルを削除すれば、HF Jobs の一時ディスク（50 GB）でも全シャードを処理できる |
| |
| ``--workers`` でシャード並列に処理する。各ワーカーはワードリスト・ブロックリスト・ |
| 共起規則を1回だけ読み込む（UT1 adult リストで約1.6 GB/ワーカー）。 |
| ``shard_summary.json`` が既にあるシャードと、``--skip-existing-in-repo`` で |
| リポジトリに既に出力があるシャードは飛ばすので、途中終了後の再実行ができる。 |
| |
| uv run python abeja-cc-ja/src/run_shard.py --input-dir <dir> --output-root <out> --workers 7 \\ |
| --upload-repo Podtech/abeja-cc-ja-cleaned --upload-prefix outputs/common_crawl_0 --delete-local-after-upload |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import multiprocessing as mp |
| import os |
| import shutil |
| import time |
| import traceback |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from typing import Any |
|
|
| import pyarrow.parquet as pq |
|
|
|
|
| PIPELINE_VERSION = "abeja-cc-ja-cleansing/2026-09-04" |
| MODE = "distinct_terms_3plus" |
|
|
| _WORKER: dict[str, Any] = {} |
|
|
|
|
| def _init_worker(config: dict[str, Any]) -> None: |
| """ワーカー起動時にリソースを1回だけ読み込む。""" |
|
|
| import sys |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| from cooccurrence import CooccurrenceDetector, load_rules |
| from domain_blocklist import DomainBlocklist |
|
|
| _WORKER["config"] = config |
| _WORKER["blocklist"] = None if config["no_blocklist"] else DomainBlocklist.load(Path(config["blocklist_dir"]), Path(config["blocklist_cache_dir"])) |
| _WORKER["cooccurrence"] = None if config["no_cooccurrence"] else CooccurrenceDetector(load_rules(Path(config["cooccurrence_rules"]))) |
|
|
|
|
| def process_shard(input_path: Path, output_root: Path, config: dict[str, Any]) -> dict[str, Any]: |
| """1シャードを処理し、shard_summary を返す（ワーカー内で実行）。""" |
|
|
| from filter_pii import run_filter as run_pii |
| from filter_toxic import run_toxic_filters |
|
|
| if not _WORKER: |
| _init_worker(config) |
| shard = input_path.stem |
| out_dir = output_root / shard |
| out_dir.mkdir(parents=True, exist_ok=True) |
| started = time.perf_counter() |
| started_at = datetime.now(timezone.utc).isoformat() |
| input_rows = pq.ParquetFile(input_path).metadata.num_rows |
|
|
| t0 = time.perf_counter() |
| toxic = run_toxic_filters( |
| input_path=input_path, |
| output_root=out_dir / "toxic", |
| reference_dir=Path(config["reference_dir"]), |
| additional_dir=Path(config["additional_dir"]), |
| batch_size=config["batch_size"], |
| modes=[MODE], |
| exclude_dir=Path(config["exclude_dir"]), |
| blocklist=_WORKER["blocklist"], |
| cooccurrence=_WORKER["cooccurrence"], |
| ) |
| toxic_seconds = time.perf_counter() - t0 |
| toxic_mode = toxic["modes"][MODE] |
| retained_path = out_dir / "toxic" / MODE / "retained.parquet" |
|
|
| t0 = time.perf_counter() |
| pii = run_pii( |
| input_path=retained_path, |
| output_root=out_dir / "pii", |
| batch_size=config["batch_size"], |
| policy_approver=config.get("policy_approver"), |
| policy_approved_on=config.get("policy_approved_on"), |
| policy_note=config.get("policy_note"), |
| ) |
| pii_seconds = time.perf_counter() - t0 |
|
|
| final_path = out_dir / f"{shard}.parquet" |
| shutil.move(str(out_dir / "pii" / "pii_replaced" / "replaced.parquet"), str(final_path)) |
| if not config.get("keep_intermediate"): |
| retained_path.unlink(missing_ok=True) |
| final_rows = pq.ParquetFile(final_path).metadata.num_rows |
|
|
| summary = { |
| "pipeline_version": PIPELINE_VERSION, |
| "shard": shard, |
| "input_file": str(input_path), |
| "input_rows": input_rows, |
| "started_at_utc": started_at, |
| "finished_at_utc": datetime.now(timezone.utc).isoformat(), |
| "seconds": {"toxic": round(toxic_seconds, 1), "pii": round(pii_seconds, 1), "total": round(time.perf_counter() - started, 1)}, |
| "toxic": { |
| "mode": MODE, |
| "threshold": toxic_mode["threshold"], |
| "category_thresholds": toxic_mode.get("category_thresholds", {}), |
| "records_scanned": toxic_mode["total_records_scanned"], |
| "records_deleted": toxic_mode["records_deleted"], |
| "records_retained": toxic_mode["records_retained"], |
| "records_deleted_by_reason": toxic_mode["records_deleted_by_reason"], |
| "by_category": {c: {"records_with_match": v["records_with_match"], "records_deleted": v["records_deleted"]} for c, v in toxic_mode["by_category"].items()}, |
| "domain_blocklist_by_source": {k: v for k, v in toxic_mode.get("domain_blocklist", {}).get("by_source", {}).items()}, |
| "domain_blocklist_sources": toxic_mode.get("domain_blocklist", {}).get("sources"), |
| "cooccurrence_by_rule": {k: {"records_matched": v["records_matched"]} for k, v in toxic_mode.get("cooccurrence", {}).get("by_rule", {}).items()}, |
| "wordlist_excluded_terms_by_category": toxic_mode.get("wordlist_excluded_terms_by_category"), |
| "wordlist_unique_terms_by_category": toxic.get("wordlist_unique_terms_by_category"), |
| }, |
| "pii": { |
| "records_scanned": pii["total_records_scanned"], |
| "records_with_replacement": pii["records_with_replacement"], |
| "total_replacements": pii["total_replacements"], |
| "by_type": {k: {"records_with_match": v["records_with_match"], "replacement_count": v["replacement_count"]} for k, v in pii["by_type"].items()}, |
| "policy": pii["pii_policy"], |
| "detector_version": pii.get("detector_version"), |
| }, |
| "output": { |
| "cleaned_parquet": str(final_path), |
| "final_rows": final_rows, |
| "removed_jsonl": str(out_dir / "toxic" / MODE / "removed.jsonl"), |
| "cooccurrence_review_jsonl": str(out_dir / "toxic" / MODE / "cooccurrence_review.jsonl"), |
| "flagged_jsonl": str(out_dir / "toxic" / MODE / "flagged.jsonl"), |
| "borderline_jsonl": str(out_dir / "toxic" / MODE / "borderline.jsonl"), |
| "pii_audit_jsonl": str(out_dir / "pii" / "pii_replaced" / "audit.jsonl"), |
| }, |
| } |
| (out_dir / "shard_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") |
| return summary |
|
|
|
|
| def _worker_entry(args: tuple[str, str, dict[str, Any]]) -> dict[str, Any]: |
| input_path, output_root, config = args |
| try: |
| return process_shard(Path(input_path), Path(output_root), config) |
| except Exception as error: |
| return {"shard": Path(input_path).stem, "input_file": input_path, "error": repr(error), "traceback": traceback.format_exc()} |
|
|
|
|
| class Uploader: |
| """完了したシャードのディレクトリをまとめて HF データセットへアップロードする。""" |
|
|
| def __init__(self, repo_id: str, prefix: str, output_root: Path, batch: int, delete_local: bool, private: bool = True) -> None: |
| from huggingface_hub import HfApi |
|
|
| self.api = HfApi() |
| self.repo_id = repo_id |
| self.prefix = prefix.strip("/") |
| self.output_root = output_root |
| self.batch = max(1, batch) |
| self.delete_local = delete_local |
| self.pending: list[str] = [] |
| self.uploaded: list[str] = [] |
| self.api.create_repo(repo_id, repo_type="dataset", private=private, exist_ok=True) |
|
|
| def existing_shards(self) -> set[str]: |
| files = self.api.list_repo_files(self.repo_id, repo_type="dataset") |
| marker = f"{self.prefix}/" |
| return {path[len(marker):].split("/", 1)[0] for path in files if path.startswith(marker) and path.endswith("/shard_summary.json")} |
|
|
| def add(self, shard: str) -> None: |
| self.pending.append(shard) |
| if len(self.pending) >= self.batch: |
| self.flush() |
|
|
| def flush(self) -> None: |
| if not self.pending: |
| return |
| shards = list(self.pending) |
| for attempt in range(5): |
| try: |
| self.api.upload_folder( |
| repo_id=self.repo_id, |
| repo_type="dataset", |
| folder_path=str(self.output_root), |
| path_in_repo=self.prefix, |
| allow_patterns=[f"{shard}/**" for shard in shards], |
| commit_message=f"add {len(shards)} shard(s): {shards[0]}..{shards[-1]}", |
| ) |
| break |
| except Exception as error: |
| wait = 30 * (attempt + 1) |
| print(json.dumps({"event": "upload_retry", "attempt": attempt + 1, "error": repr(error), "wait_s": wait}), flush=True) |
| time.sleep(wait) |
| else: |
| raise RuntimeError(f"アップロードに失敗しました: {shards}") |
| self.uploaded.extend(shards) |
| self.pending.clear() |
| print(json.dumps({"event": "uploaded", "shards": shards, "repo": self.repo_id, "prefix": self.prefix}), flush=True) |
| if self.delete_local: |
| for shard in shards: |
| shutil.rmtree(self.output_root / shard, ignore_errors=True) |
|
|
|
|
| def main(argv: list[str] | None = None) -> None: |
| source_dir = Path(__file__).resolve().parent |
| project_root = source_dir.parent |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| group = parser.add_mutually_exclusive_group(required=True) |
| group.add_argument("--input", type=Path, action="append", help="入力parquet（複数可）") |
| group.add_argument("--input-dir", type=Path, help="入力parquetのディレクトリ") |
| parser.add_argument("--pattern", default="*.parquet") |
| parser.add_argument("--limit-shards", type=int, default=None, help="先頭N件だけ処理する（試運転用）") |
| parser.add_argument("--output-root", type=Path, required=True) |
| parser.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 2) - 1)) |
| parser.add_argument("--batch-size", type=int, default=2048) |
| parser.add_argument("--keep-intermediate", action="store_true", help="有害フィルタ後の retained.parquet を残す") |
| parser.add_argument("--reference-dir", type=Path, default=source_dir / "wordlists" / "reference") |
| parser.add_argument("--additional-dir", type=Path, default=source_dir / "wordlists") |
| parser.add_argument("--exclude-dir", type=Path, default=source_dir / "wordlists" / "exclude") |
| parser.add_argument("--blocklist-dir", type=Path, default=source_dir / "blocklists") |
| parser.add_argument("--blocklist-cache-dir", type=Path, default=project_root / "data" / "blocklists" / "ut1") |
| parser.add_argument("--no-blocklist", action="store_true") |
| parser.add_argument("--cooccurrence-rules", type=Path, default=source_dir / "wordlists" / "cooccurrence" / "rules.json") |
| parser.add_argument("--no-cooccurrence", action="store_true") |
| parser.add_argument("--policy-approver", default=None) |
| parser.add_argument("--policy-approved-on", default=None) |
| parser.add_argument("--policy-note", default=None) |
| parser.add_argument("--upload-repo", default=None, help="出力先の HF データセット（例: Podtech/abeja-cc-ja-cleaned）。非公開で作成する") |
| parser.add_argument("--upload-prefix", default="outputs", help="リポジトリ内のパス接頭辞（例: outputs/common_crawl_0）") |
| parser.add_argument("--upload-batch", type=int, default=5, help="何シャードごとに1コミットでアップロードするか") |
| parser.add_argument("--delete-local-after-upload", action="store_true") |
| parser.add_argument("--skip-existing-in-repo", action="store_true", help="リポジトリに shard_summary.json があるシャードを飛ばす") |
| args = parser.parse_args(argv) |
|
|
| if args.input_dir: |
| inputs = sorted(args.input_dir.glob(args.pattern)) |
| else: |
| inputs = list(args.input) |
| if args.limit_shards is not None: |
| inputs = inputs[: args.limit_shards] |
| if not inputs: |
| raise FileNotFoundError("入力parquetが見つかりません") |
| args.output_root.mkdir(parents=True, exist_ok=True) |
|
|
| uploader = None |
| skip: set[str] = set() |
| if args.upload_repo: |
| uploader = Uploader(args.upload_repo, args.upload_prefix, args.output_root, args.upload_batch, args.delete_local_after_upload) |
| if args.skip_existing_in_repo: |
| skip = uploader.existing_shards() |
| todo = [] |
| for path in inputs: |
| shard = path.stem |
| if shard in skip or (args.output_root / shard / "shard_summary.json").exists(): |
| print(json.dumps({"event": "skip", "shard": shard}), flush=True) |
| continue |
| todo.append(path) |
|
|
| config = { |
| "batch_size": args.batch_size, |
| "keep_intermediate": args.keep_intermediate, |
| "reference_dir": str(args.reference_dir), "additional_dir": str(args.additional_dir), "exclude_dir": str(args.exclude_dir), |
| "blocklist_dir": str(args.blocklist_dir), "blocklist_cache_dir": str(args.blocklist_cache_dir), "no_blocklist": args.no_blocklist, |
| "cooccurrence_rules": str(args.cooccurrence_rules), "no_cooccurrence": args.no_cooccurrence, |
| "policy_approver": args.policy_approver, "policy_approved_on": args.policy_approved_on, "policy_note": args.policy_note, |
| } |
| run_started = time.perf_counter() |
| results: list[dict[str, Any]] = [] |
| print(json.dumps({"event": "start", "shards": len(todo), "skipped": len(inputs) - len(todo), "workers": args.workers, "output_root": str(args.output_root)}), flush=True) |
| jobs = [(str(path), str(args.output_root), config) for path in todo] |
| if args.workers <= 1 or len(jobs) <= 1: |
| _init_worker(config) |
| iterator = map(_worker_entry, jobs) |
| else: |
| |
| context = mp.get_context("spawn") |
| pool = context.Pool(processes=min(args.workers, len(jobs)), initializer=_init_worker, initargs=(config,)) |
| iterator = pool.imap_unordered(_worker_entry, jobs) |
| for result in iterator: |
| results.append(result) |
| if "error" in result: |
| print(json.dumps({"event": "error", "shard": result["shard"], "error": result["error"]}), flush=True) |
| continue |
| print(json.dumps({ |
| "event": "done", "shard": result["shard"], "input_rows": result["input_rows"], |
| "toxic_deleted": result["toxic"]["records_deleted"], "pii_replacements": result["pii"]["total_replacements"], |
| "final_rows": result["output"]["final_rows"], "seconds": result["seconds"]["total"], |
| }, ensure_ascii=False), flush=True) |
| if uploader is not None: |
| uploader.add(result["shard"]) |
| if uploader is not None: |
| uploader.flush() |
| errors = [r for r in results if "error" in r] |
| run_summary = { |
| "pipeline_version": PIPELINE_VERSION, |
| "finished_at_utc": datetime.now(timezone.utc).isoformat(), |
| "shards_processed": len(results) - len(errors), |
| "shards_failed": [{"shard": r["shard"], "error": r["error"]} for r in errors], |
| "shards_skipped": len(inputs) - len(todo), |
| "seconds": round(time.perf_counter() - run_started, 1), |
| "upload_repo": args.upload_repo, |
| "upload_prefix": args.upload_prefix if args.upload_repo else None, |
| } |
| (args.output_root / f"run_summary_{datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%SZ')}.json").write_text(json.dumps(run_summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") |
| print(json.dumps({"event": "finish", **run_summary}, ensure_ascii=False), flush=True) |
| if errors: |
| raise SystemExit(1) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
