| """シャード単位のクレンジングパイプライン（本実行用）。 |
| |
| 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 stage_input(input_path: Path, staging_dir: Path | None, attempts: int = 5, wait_seconds: int = 20) -> Path: |
| """マウントされたデータセット（FUSE）は読み取り中に I/O エラー（errno 5）を起こすことがあるため、 |
| まずローカルディスクへコピーしてから処理する。コピー自体も再試行する。""" |
|
|
| if staging_dir is None: |
| return input_path |
| staging_dir.mkdir(parents=True, exist_ok=True) |
| local = staging_dir / input_path.name |
| last_error: Exception | None = None |
| for attempt in range(1, attempts + 1): |
| try: |
| shutil.copyfile(input_path, local) |
| if local.stat().st_size == input_path.stat().st_size: |
| return local |
| last_error = OSError(f"size mismatch after copy: {local}") |
| except OSError as error: |
| last_error = error |
| print(json.dumps({"event": "stage_retry", "shard": input_path.stem, "attempt": attempt, "error": repr(last_error)[:160]}), flush=True) |
| time.sleep(wait_seconds * attempt) |
| raise OSError(f"入力の退避に失敗しました: {input_path} ({last_error!r})") |
|
|
|
|
| def _worker_entry(args: tuple[str, str, dict[str, Any]]) -> dict[str, Any]: |
| input_path, output_root, config = args |
| staging_dir = Path(config["staging_dir"]) if config.get("staging_dir") else None |
| local_input: Path | None = None |
| last_error: Exception | None = None |
| for attempt in range(1, 4): |
| try: |
| local_input = stage_input(Path(input_path), staging_dir) |
| result = process_shard(local_input, Path(output_root), config) |
| result["input_file"] = input_path |
| return result |
| except OSError as error: |
| last_error = error |
| print(json.dumps({"event": "io_retry", "shard": Path(input_path).stem, "attempt": attempt, "error": repr(error)[:160]}), flush=True) |
| time.sleep(30 * attempt) |
| except Exception as error: |
| return {"shard": Path(input_path).stem, "input_file": input_path, "error": repr(error), "traceback": traceback.format_exc()} |
| finally: |
| if local_input is not None and staging_dir is not None and local_input != Path(input_path): |
| local_input.unlink(missing_ok=True) |
| return {"shard": Path(input_path).stem, "input_file": input_path, "error": repr(last_error), "traceback": ""} |
|
|
|
|
| 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, marker: str = "shard_summary.json") -> set[str]: |
| """接頭辞直下のディレクトリ名を返す。全ファイル一覧はリポジトリが数万ファイルになると数分かかるため使わない。 |
| シャードは upload_folder で1コミットにまとめるので、ディレクトリの存在＝完了とみなす。""" |
|
|
| for attempt in range(5): |
| try: |
| entries = self.api.list_repo_tree(self.repo_id, path_in_repo=self.prefix, repo_type="dataset", recursive=False) |
| return {e.path.rsplit("/", 1)[-1] for e in entries if type(e).__name__ == "RepoFolder"} |
| except Exception as error: |
| if "404" in repr(error) or "not found" in repr(error).lower(): |
| return set() |
| time.sleep(30 * (attempt + 1)) |
| raise RuntimeError("list_repo_tree failed after retries") |
|
|
| 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 があるシャードを飛ばす") |
| parser.add_argument("--staging-dir", type=Path, default=None, help="入力parquetを処理前にコピーするローカルディレクトリ（マウントの I/O エラー対策）") |
| 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, |
| "staging_dir": str(args.staging_dir) if args.staging_dir else None, |
| } |
| 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() |
|
|
