handoff runner d8f929e8

code/handoff/d8f929e8-470ccc8b/abeja_handoff.py

@@ -0,0 +1,416 @@
+"""abeja-cc-ja ハンドオフ版品質フィルター（abeja_cc_filter_handoff_20260909 の stage1〜stage8）を全シャードへ適用する。
+
+判定は 3 値（keep / review / reject）。出力パーケットからは reject だけを除去し、keep と review は残す。
+keep は 1.3% 程度しかない「高精度な学習候補」であり、コーパスフィルターではないため。
+判定ロジックは配布物のスクリプトをそのまま import して使う（改変なし）。評価用の付随出力
+（accepted/review/rejected/train_clean/blind_audit）は生成しない。
+
+    python tools/abeja_handoff.py --calibrate --files a.parquet --handoff-dir <配布物>
+    python tools/abeja_handoff.py --repo Podtech/abeja-cc-ja-cleaned --source-prefix outputs_v5 --dir common_crawl_0 \
+        --handoff-dir /work/handoff --output-root /work/out/common_crawl_0 --upload-repo ... --upload-prefix outputs_v6
+    # 原本（PII 未処理、data/<dir>/<shard>.parquet の平置き）に当てる場合
+    python tools/abeja_handoff.py --repo Podtech/abeja-cc-ja-filtered --source-prefix data --input-layout flat \
+        --redact-pii --dir common_crawl_0 --handoff-dir /work/handoff --output-root /work/out/common_crawl_0 \
+        --upload-repo Podtech/abeja-cc-ja-filtered --upload-prefix handoff
+"""
+from __future__ import annotations
+
+import argparse
+import collections
+import importlib
+import io
+import json
+import os
+import shutil
+import sys
+import time
+import traceback
+from concurrent.futures import ProcessPoolExecutor
+from contextlib import redirect_stdout
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+VERSION = "abeja-handoff/2026-09-09"
+STAGE_MODULES = (
+    "filter_podtech_quality",
+    "filter_podtech_stage2",
+    "filter_podtech_stage3",
+    "filter_podtech_stage4",
+    "filter_podtech_stage5",
+    "filter_podtech_stage6",
+    "filter_podtech_stage7",
+    "filter_podtech_stage8",
+)
+_MODS: dict[str, Any] = {}
+_HANDOFF: dict[str, Path] = {}
+
+
+def _noop_int(*_args: Any, **_kwargs: Any) -> int:
+    """write_full / write_train の差し替え。判定には影響しない付随出力を書かない。"""
+    return 0
+
+
+def _noop_counts(*_args: Any, **_kwargs: Any) -> dict[str, int]:
+    """write_blind_audit の差し替え。評価用の層別標本は本番適用では使わない。"""
+    return {}
+
+
+def _load_stages(handoff_dir: Path) -> None:
+    """配布物の scripts/ を import し、付随出力の書き出しだけを無効化する。"""
+    if _MODS:
+        return
+    scripts = handoff_dir / "scripts"
+    if not (scripts / "filter_podtech_stage8.py").exists():
+        raise FileNotFoundError(f"handoff scripts not found under {scripts}")
+    sys.path.insert(0, str(scripts))
+    for name in STAGE_MODULES:
+        _MODS[name] = importlib.import_module(name)
+    # 各モジュール名前空間の束縛を個別に差し替える（stage5 以降は stage4 から import しているため）
+    for mod in _MODS.values():
+        for attr, replacement in (
+            ("write_full", _noop_int),
+            ("write_train", _noop_int),
+            ("write_blind_audit", _noop_counts),
+        ):
+            if hasattr(mod, attr):
+                setattr(mod, attr, replacement)
+    _HANDOFF["dir"] = handoff_dir
+    _HANDOFF["v1"] = handoff_dir / "models" / "v1_multiclass" / "quality_char_ngram_model.joblib"
+    _HANDOFF["v2"] = handoff_dir / "models" / "v2_binary" / "quality_binary_model.joblib"
+
+
+def _run_stage(name: str, argv: list[str]) -> dict:
+    """配布物の main() を argv 付きで呼び、書き出された summary.json を返す。"""
+    mod = _MODS[name]
+    saved = sys.argv
+    sys.argv = [name] + argv
+    try:
+        with redirect_stdout(io.StringIO()):
+            mod.main()
+    finally:
+        sys.argv = saved
+    out_dir = Path(argv[argv.index("--output-dir") + 1])
+    return json.loads((out_dir / "summary.json").read_text(encoding="utf-8"))
+
+
+def score_model(input_path: Path, model_path: Path, kind: str, output: Path, batch_size: int = 2000) -> None:
+    """配布物の学習済みモデルで全件採点する（学習はしない）。列は配布物の ml_scores.parquet と同一。"""
+    import duckdb
+    import joblib
+    import numpy as np
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    limit = 6000 if kind == "v1" else 8000
+    model = joblib.load(model_path)
+    con = duckdb.connect()
+    sql = str(input_path.resolve()).replace("'", "''")
+    cursor = con.execute(f"SELECT row_number() OVER () - 1 AS row_id, url, content FROM read_parquet('{sql}')")
+    if kind == "v1":
+        schema = pa.schema([("row_id", pa.int64()), ("ml_prediction", pa.string()),
+                            ("prob_A", pa.float64()), ("prob_B", pa.float64()), ("prob_C", pa.float64())])
+    else:
+        schema = pa.schema([("row_id", pa.int64()), ("ml_v2_prediction", pa.string()),
+                            ("prob_non_C", pa.float64()), ("prob_C", pa.float64())])
+    writer = pq.ParquetWriter(output, schema, compression="zstd")
+    try:
+        while True:
+            rows = cursor.fetchmany(batch_size)
+            if not rows:
+                break
+            texts = [f"URL {u or ''}\n本文 {(c or '')[:limit]}" for _, u, c in rows]
+            probs = model.predict_proba(texts)
+            out: list[dict] = []
+            if kind == "v1":
+                classes = model.classes_
+                predictions = classes[np.argmax(probs, axis=1)]
+                for (row_id, _, _), prediction, probability in zip(rows, predictions, probs):
+                    by_class = dict(zip(classes, probability))
+                    out.append({"row_id": row_id, "ml_prediction": str(prediction),
+                                "prob_A": float(by_class["A"]), "prob_B": float(by_class["B"]),
+                                "prob_C": float(by_class["C"])})
+            else:
+                for (row_id, _, _), probability in zip(rows, probs[:, 1]):
+                    out.append({"row_id": row_id, "ml_v2_prediction": "C" if probability >= 0.5 else "non_C",
+                                "prob_non_C": float(1 - probability), "prob_C": float(probability)})
+            writer.write_table(pa.Table.from_pylist(out, schema=schema))
+    finally:
+        writer.close()
+    del model
+
+
+def run_chain(input_path: Path, work: Path) -> tuple[Path, dict[str, dict]]:
+    """stage1〜stage8 を順に実行し、(stage8_audit.parquet, 段階別 summary) を返す。"""
+    work.mkdir(parents=True, exist_ok=True)
+    stages: dict[str, dict] = {}
+    inp = str(input_path)
+
+    stages["stage1"] = _run_stage("filter_podtech_quality", ["--input", inp, "--output-dir", str(work / "s1")])
+    for name in ("kept.parquet", "review.parquet", "rejected.parquet"):
+        (work / "s1" / name).unlink(missing_ok=True)
+
+    score_model(input_path, _HANDOFF["v1"], "v1", work / "ml1.parquet")
+    stages["stage2"] = _run_stage("filter_podtech_stage2", [
+        "--input", inp, "--stage1-audit", str(work / "s1" / "quality_audit.parquet"),
+        "--ml-scores", str(work / "ml1.parquet"), "--output-dir", str(work / "s2")])
+
+    score_model(input_path, _HANDOFF["v2"], "v2", work / "ml2.parquet")
+    stages["stage3"] = _run_stage("filter_podtech_stage3", [
+        "--input", inp, "--stage2-audit", str(work / "s2" / "stage2_audit.parquet"),
+        "--ml-v2-scores", str(work / "ml2.parquet"), "--output-dir", str(work / "s3")])
+    stages["stage4"] = _run_stage("filter_podtech_stage4", [
+        "--input", inp, "--stage2-audit", str(work / "s2" / "stage2_audit.parquet"),
+        "--stage3-audit", str(work / "s3" / "stage3_audit.parquet"), "--output-dir", str(work / "s4")])
+    stages["stage5"] = _run_stage("filter_podtech_stage5", [
+        "--input", inp, "--stage2-audit", str(work / "s2" / "stage2_audit.parquet"),
+        "--stage4-audit", str(work / "s4" / "stage4_audit.parquet"), "--output-dir", str(work / "s5")])
+    stages["stage6"] = _run_stage("filter_podtech_stage6", [
+        "--input", inp, "--stage5-audit", str(work / "s5" / "stage5_audit.parquet"), "--output-dir", str(work / "s6")])
+    stages["stage7"] = _run_stage("filter_podtech_stage7", [
+        "--input", inp, "--stage6-audit", str(work / "s6" / "stage6_audit.parquet"), "--output-dir", str(work / "s7")])
+    stages["stage8"] = _run_stage("filter_podtech_stage8", [
+        "--input", inp, "--stage7-audit", str(work / "s7" / "stage7_audit.parquet"), "--output-dir", str(work / "s8")])
+    return work / "s8" / "stage8_audit.parquet", stages
+
+
+def _fetch(repo: str, path_in_repo: str, local_dir: Path, attempts: int = 6) -> Path:
+    from huggingface_hub import hf_hub_download
+    for k in range(attempts):
+        try:
+            return Path(hf_hub_download(repo, path_in_repo, repo_type="dataset",
+                                        token=os.environ.get("HF_TOKEN"), local_dir=str(local_dir)))
+        except Exception:  # noqa: BLE001
+            if k == attempts - 1:
+                raise
+            time.sleep(20 * (k + 1))
+    raise RuntimeError("unreachable")
+
+
+def process_shard(task: dict) -> dict:
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    started = time.perf_counter()
+    shard = task["shard"]
+    work = Path(task["staging_dir"]) / f"{shard}_work"
+    local: Path | None = None
+    try:
+        _load_stages(Path(task["handoff_dir"]))
+        local = _fetch(task["repo"], task["path"], Path(task["staging_dir"])) if task.get("repo") else Path(task["path"])
+        out_dir = Path(task["output_root"]) / shard
+        out_dir.mkdir(parents=True, exist_ok=True)
+        shutil.rmtree(work, ignore_errors=True)
+        audit_path, stages = run_chain(local, work)
+
+        audit = pq.read_table(audit_path, columns=["row_id", "decision", "reasons", "source_class", "prob_C"])
+        decision = dict(zip(audit.column("row_id").to_pylist(), audit.column("decision").to_pylist()))
+        reasons = dict(zip(audit.column("row_id").to_pylist(), audit.column("reasons").to_pylist()))
+        source = dict(zip(audit.column("row_id").to_pylist(), audit.column("source_class").to_pylist()))
+        pq.write_table(audit, out_dir / "handoff_decisions.parquet", compression="zstd")
+
+        redact = _MODS["filter_podtech_stage2"].redact_direct_pii if task.get("redact_pii") else None
+        pf = pq.ParquetFile(local)
+        codec = pf.metadata.row_group(0).column(0).compression if pf.metadata.num_row_groups else "SNAPPY"
+        writer = pq.ParquetWriter(out_dir / f"{shard}.parquet", pf.schema_arrow,
+                                  compression=codec.lower() if codec != "UNCOMPRESSED" else None)
+        removed_f = (out_dir / "handoff_removed.jsonl").open("w", encoding="utf-8")
+        counts: collections.Counter[str] = collections.Counter()
+        reject_reasons: collections.Counter[str] = collections.Counter()
+        rows_in = 0
+        written = 0
+        pii_replacements = 0
+        pii_docs = 0
+        try:
+            for batch in pf.iter_batches(batch_size=2048):
+                d = batch.to_pydict()
+                n = batch.num_rows
+                keep_idx = []
+                new_content = list(d["content"])
+                for i in range(n):
+                    row = rows_in + i
+                    verdict = decision.get(row)
+                    if verdict is None:
+                        raise ValueError(f"row_id {row} missing from stage8 audit")
+                    counts[verdict] += 1
+                    if verdict == "reject":
+                        reject_reasons[reasons.get(row) or ""] += 1
+                        removed_f.write(json.dumps({
+                            "row_index": row, "decision": verdict, "reasons": reasons.get(row),
+                            "source_class": source.get(row), "url": d["url"][i], "content": d["content"][i],
+                            "perplexity": d.get("perplexity", [None] * n)[i],
+                        }, ensure_ascii=False, default=str) + "\n")
+                    else:
+                        if redact is not None and new_content[i]:
+                            new_content[i], replaced = redact(new_content[i])
+                            if replaced:
+                                pii_replacements += replaced
+                                pii_docs += 1
+                        keep_idx.append(i)
+                if keep_idx:
+                    cols = {}
+                    for name in pf.schema_arrow.names:
+                        values = new_content if name == "content" else d[name]
+                        cols[name] = pa.array([values[i] for i in keep_idx], type=pf.schema_arrow.field(name).type)
+                    kept = pa.record_batch(cols, schema=pf.schema_arrow)
+                    writer.write_batch(kept)
+                    written += kept.num_rows
+                rows_in += n
+        finally:
+            writer.close()
+            removed_f.close()
+        check = pq.ParquetFile(out_dir / f"{shard}.parquet")
+        assert check.metadata.num_rows == written == rows_in - counts["reject"], "row count mismatch"
+
+        summary = {
+            "version": VERSION, "dir": task["config"], "shard": shard,
+            "source_prefix": task["source_prefix"],
+            "rows_in": rows_in, "rows_removed": counts["reject"], "rows_out": written,
+            "decisions": {k: counts[k] for k in ("keep", "review", "reject", "duplicate")},
+            "reject_reasons": dict(reject_reasons.most_common()),
+            "stage_decisions": {name: s.get("decisions", {}) for name, s in stages.items()},
+            "pii_redaction": {"applied": bool(redact), "detector": "handoff redact_direct_pii (email/phone/postcode)",
+                              "documents": pii_docs, "replacements": pii_replacements},
+            "policy": {"removed": "reject", "kept": "keep+review", "content_rewritten": bool(redact)},
+            "compression": codec, "seconds": round(time.perf_counter() - started, 1),
+            "finished_at_utc": datetime.now(timezone.utc).isoformat(),
+        }
+        (out_dir / "handoff_summary.json").write_text(
+            json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        return summary
+    except Exception as error:  # noqa: BLE001
+        return {"shard": shard, "error": repr(error), "traceback": traceback.format_exc()}
+    finally:
+        shutil.rmtree(work, ignore_errors=True)
+        if task.get("repo") and local is not None:
+            Path(local).unlink(missing_ok=True)
+
+
+def upload_batch(api: Any, repo: str, prefix: str, output_root: Path, shards: list[str], delete_local: bool) -> None:
+    """複数シャードを 1 コミットでまとめる（HF のコミット制限 320/時 対策）。429 は案内の待ち時間だけ待って再試行。"""
+    import re as _re
+    for attempt in range(12):
+        try:
+            api.upload_folder(repo_id=repo, repo_type="dataset", folder_path=str(output_root), path_in_repo=prefix,
+                              allow_patterns=[f"{sh}/**" for sh in shards],
+                              commit_message=f"{Path(prefix).name} {shards[0]}..{shards[-1]} ({len(shards)} shards)")
+            break
+        except Exception as e:  # noqa: BLE001
+            msg = str(e)
+            m = _re.search(r"retry this action in (\d+) minutes", msg)
+            wait = (int(m.group(1)) * 60 + 90) if m else (120 * (attempt + 1))
+            print(json.dumps({"event": "upload_retry", "attempt": attempt + 1, "wait_s": wait, "error": msg[:160]}), flush=True)
+            if attempt == 11:
+                raise
+            time.sleep(wait)
+    if delete_local:
+        for sh in shards:
+            shutil.rmtree(output_root / sh, ignore_errors=True)
+
+
+def calibrate(files: list[str], handoff_dir: Path, staging: Path, redact: bool = False) -> None:
+    _load_stages(handoff_dir)
+    for f in files:
+        work = staging / (Path(f).stem + "_work")
+        shutil.rmtree(work, ignore_errors=True)
+        started = time.perf_counter()
+        audit_path, stages = run_chain(Path(f), work)
+        import pyarrow.parquet as pq
+        audit = pq.read_table(audit_path, columns=["decision", "reasons"])
+        counts = collections.Counter(audit.column("decision").to_pylist())
+        rej = collections.Counter(r for r, d in zip(audit.column("reasons").to_pylist(),
+                                                    audit.column("decision").to_pylist()) if d == "reject")
+        print(json.dumps({"file": f, "rows": sum(counts.values()), "decisions": dict(counts),
+                          "reject_reasons": dict(rej.most_common(10)),
+                          "stage_decisions": {k: v.get("decisions", {}) for k, v in stages.items()},
+                          "seconds": round(time.perf_counter() - started, 1)}, ensure_ascii=False))
+        shutil.rmtree(work, ignore_errors=True)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--calibrate", action="store_true")
+    parser.add_argument("--files", default="")
+    parser.add_argument("--handoff-dir", type=Path, required=True, help="配布物のルート（scripts/ と models/ を含む）")
+    parser.add_argument("--repo", default=None)
+    parser.add_argument("--source-prefix", default="outputs_v5")
+    parser.add_argument("--input-layout", choices=("nested", "flat"), default="nested",
+                        help="nested: <prefix>/<dir>/<shard>/<shard>.parquet、flat: <prefix>/<dir>/<shard>.parquet")
+    parser.add_argument("--redact-pii", action="store_true",
+                        help="配布物の redact_direct_pii（メール・電話・郵便番号）を保持行の本文へ適用する")
+    parser.add_argument("--dir", default=None)
+    parser.add_argument("--output-root", type=Path, default=None)
+    parser.add_argument("--staging-dir", type=Path, default=Path("/work/staging"))
+    parser.add_argument("--limit-shards", type=int, default=None)
+    parser.add_argument("--shard-index", type=int, default=0, help="--shard-total 分割のうち何番目を担当するか")
+    parser.add_argument("--shard-total", type=int, default=1, help="1 ディレクトリを何ジョブに分割するか")
+    parser.add_argument("--upload-repo", default=None)
+    parser.add_argument("--upload-prefix", default="outputs_v6")
+    parser.add_argument("--upload-batch", type=int, default=10)
+    parser.add_argument("--skip-existing-in-repo", action="store_true")
+    parser.add_argument("--workers", type=int, default=max(1, int(os.environ.get("CPU_CORES") or os.cpu_count() or 2) - 1))
+    args = parser.parse_args(argv)
+
+    args.staging_dir.mkdir(parents=True, exist_ok=True)
+    if args.calibrate:
+        calibrate([f for f in args.files.split(",") if f], args.handoff_dir, args.staging_dir,
+                  redact=args.redact_pii)
+        return
+
+    from huggingface_hub import HfApi
+    api = HfApi(token=os.environ.get("HF_TOKEN"))
+    entries = list(api.list_repo_tree(args.repo, path_in_repo=f"{args.source_prefix}/{args.dir}",
+                                      repo_type="dataset", recursive=False))
+    if args.input_layout == "flat":
+        # data/<dir>/<shard>.parquet。_DONE などの付随ファイルは除く
+        shards = sorted({e.path.split("/")[-1][: -len(".parquet")]
+                         for e in entries if e.path.endswith(".parquet")})
+    else:
+        shards = sorted({e.path.split("/")[-1] for e in entries})
+    if args.limit_shards:
+        shards = shards[: args.limit_shards]
+    if args.shard_total > 1:
+        shards = shards[args.shard_index :: args.shard_total]
+    existing: set[str] = set()
+    if args.skip_existing_in_repo and args.upload_repo:
+        try:
+            existing = {e.path.split("/")[-1] for e in api.list_repo_tree(
+                args.upload_repo, path_in_repo=f"{args.upload_prefix}/{args.dir}", repo_type="dataset", recursive=False)}
+        except Exception:  # noqa: BLE001
+            existing = set()
+    def source_path(sh: str) -> str:
+        if args.input_layout == "flat":
+            return f"{args.source_prefix}/{args.dir}/{sh}.parquet"
+        return f"{args.source_prefix}/{args.dir}/{sh}/{sh}.parquet"
+
+    tasks = [{"repo": args.repo, "path": source_path(sh),
+              "shard": sh, "config": args.dir, "source_prefix": args.source_prefix,
+              "output_root": str(args.output_root), "staging_dir": str(args.staging_dir),
+              "handoff_dir": str(args.handoff_dir), "redact_pii": args.redact_pii}
+             for sh in shards if sh not in existing]
+    print(json.dumps({"event": "start", "dir": args.dir, "shards": len(shards),
+                      "shard_index": args.shard_index, "shard_total": args.shard_total,
+                      "skipped_existing": len(shards) - len(tasks), "workers": args.workers}), flush=True)
+    pending: list[str] = []
+    failed: list[str] = []
+    with ProcessPoolExecutor(max_workers=args.workers) as ex:
+        for s in ex.map(process_shard, tasks):
+            if "error" in s:
+                failed.append(s["shard"])
+                print(json.dumps({"event": "error", **s}, ensure_ascii=False)[:800], flush=True)
+                continue
+            print(json.dumps({"event": "done", **{k: v for k, v in s.items()
+                                                  if k not in ("version", "finished_at_utc", "compression", "stage_decisions")}},
+                             ensure_ascii=False), flush=True)
+            if args.upload_repo:
+                pending.append(s["shard"])
+                if len(pending) >= args.upload_batch:
+                    upload_batch(api, args.upload_repo, f"{args.upload_prefix}/{args.dir}", args.output_root, pending, True)
+                    pending = []
+    if args.upload_repo and pending:
+        upload_batch(api, args.upload_repo, f"{args.upload_prefix}/{args.dir}", args.output_root, pending, True)
+    print(json.dumps({"event": "finish", "dir": args.dir, "shards": len(tasks), "failed": failed}), flush=True)
+
+
+if __name__ == "__main__":
+    main()