decontam script 03607066

code/decontam/03607066/contamination_scan.py

@@ -0,0 +1,193 @@
+"""ベンチマーク除染の走査（CPU）: 評価データ由来の文字 n-gram パターン（patterns.parquet）を Aho-Corasick でコーパス全件に当て、
+一致した文書（ファイル・行番号・URL・一致したベンチマーク／設問／フィールド）と件数を出す。
+
+正規化はパターン作成側と同じ: NFKC → casefold → 空白（全角含む）を全削除。
+
+    python contamination_scan.py --repo Podtech/abeja-cc-ja-cleaned --prefix outputs_v4/common_crawl_0 --pattern "*/*.parquet" --text-column content \
+        --patterns patterns.parquet --part abeja_0 --output-dir out
+"""
+
+from __future__ import annotations
+
+import argparse
+import fnmatch
+import json
+import os
+import re
+import time
+import traceback
+import unicodedata
+from collections import Counter
+from concurrent.futures import ProcessPoolExecutor
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import pyarrow.parquet as pq
+
+VERSION = "contamination-scan/2026-09-07-v2"
+_WS = re.compile(r"\s+")
+_CFG: dict[str, Any] = {}
+_AUTO: Any = None
+_REFS: list[str] = []
+
+
+def normalize(text: str) -> str:
+    return _WS.sub("", unicodedata.normalize("NFKC", text or "").casefold())
+
+
+def _init(config: dict[str, Any]) -> None:
+    global _CFG, _AUTO, _REFS
+    import ahocorasick
+
+    _CFG = config
+    t = pq.read_table(config["patterns"], columns=["ngram", "refs"])
+    A = ahocorasick.Automaton()
+    _REFS = t.column("refs").to_pylist()
+    for i, ng in enumerate(t.column("ngram").to_pylist()):
+        A.add_word(ng, i)
+    A.make_automaton()
+    _AUTO = A
+
+
+def _fetch(repo: str, path_in_repo: str, local_dir: Path, attempts: int = 6) -> Path:
+    from huggingface_hub import hf_hub_download
+
+    last: Exception | None = None
+    for attempt in range(1, attempts + 1):
+        try:
+            return Path(hf_hub_download(repo, path_in_repo, repo_type="dataset", local_dir=str(local_dir)))
+        except Exception as error:  # noqa: BLE001
+            last = error
+            print(json.dumps({"event": "download_retry", "path": path_in_repo, "attempt": attempt, "error": repr(error)[:160]}), flush=True)
+            time.sleep(20 * attempt)
+    raise RuntimeError(f"download failed: {path_in_repo} ({last!r})")
+
+
+def process_file(task: dict[str, Any]) -> dict[str, Any]:
+    started = time.perf_counter()
+    try:
+        local = _fetch(task["repo"], task["path"], Path(task["staging_dir"])) if task.get("repo") else Path(task["path"])
+        text_col = _CFG["text_column"]; url_col = _CFG.get("url_column")
+        pf = pq.ParquetFile(local)
+        cols = [text_col] + ([url_col] if url_col and url_col in pf.schema_arrow.names else [])
+        rows = 0; matched_docs = 0; per_task_docs: Counter = Counter(); per_task_examples: dict[str, set] = {}; per_field_docs: Counter = Counter(); per_field_docs_strong: Counter = Counter(); pattern_docs: Counter = Counter()
+        out_path = Path(task["matches_dir"]) / (re.sub(r"[^A-Za-z0-9_.-]", "_", task["path"]) + ".matches.jsonl")
+        with out_path.open("w", encoding="utf-8") as out:
+            offset = 0
+            for batch in pf.iter_batches(batch_size=2048, columns=cols):
+                texts = batch.column(text_col).to_pylist(); urls = batch.column(url_col).to_pylist() if len(cols) > 1 else [None] * len(texts)
+                for i, text in enumerate(texts):
+                    rows += 1
+                    if not text:
+                        continue
+                    norm = normalize(text)
+                    # 設問×フィールドごとに、一致した異なり n-gram の数を数える（1 個だけの一致は定型句の可能性が高い）
+                    hits: dict[str, dict[str, set]] = {}
+                    doc_patterns: set[int] = set()
+                    for _, idx in _AUTO.iter(norm):
+                        doc_patterns.add(idx)
+                        for ref in json.loads(_REFS[idx]):
+                            tk, ex, field = ref.split("|", 2)
+                            hits.setdefault(tk, {}).setdefault(f"{ex}|{field}", set()).add(idx)
+                    if hits:
+                        matched_docs += 1
+                        for pid in doc_patterns: pattern_docs[pid] += 1
+                        for tk, exf in hits.items():
+                            per_task_docs[tk] += 1; per_task_examples.setdefault(tk, set()).update(k.split("|")[0] for k in exf)
+                            fields_seen = {k.split("|", 1)[1] for k in exf}
+                            for f in fields_seen: per_field_docs[f"{tk}|{f}"] += 1
+                            strong_fields = {k.split("|", 1)[1] for k, ids in exf.items() if len(ids) >= 2}
+                            for f in strong_fields: per_field_docs_strong[f"{tk}|{f}"] += 1
+                        out.write(json.dumps({"file": task["path"], "row_index": offset + i, "url": (urls[i] or "")[:200] if urls[i] else None,
+                                              "tasks": {tk: {k: len(ids) for k, ids in sorted(exf.items(), key=lambda kv: -len(kv[1]))[:20]} for tk, exf in hits.items()}}, ensure_ascii=False) + "\n")
+                offset += len(texts)
+        if task.get("repo"):
+            local.unlink(missing_ok=True)
+        return {"path": task["path"], "rows": rows, "matched_docs": matched_docs, "per_task_docs": dict(per_task_docs), "per_task_examples": {k: sorted(v) for k, v in per_task_examples.items()},
+                "per_field_docs": dict(per_field_docs), "per_field_docs_strong": dict(per_field_docs_strong), "pattern_docs": dict(pattern_docs), "matches_file": str(out_path), "seconds": round(time.perf_counter() - started, 1)}
+    except Exception as error:  # noqa: BLE001
+        return {"path": task["path"], "error": repr(error), "traceback": traceback.format_exc()}
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--repo", default=None); parser.add_argument("--files", default=""); parser.add_argument("--prefix", default=None); parser.add_argument("--pattern", default="*.parquet")
+    parser.add_argument("--text-column", default="text"); parser.add_argument("--url-column", default="url")
+    parser.add_argument("--patterns", required=True, help="patterns.parquet のローカルパス")
+    parser.add_argument("--part", required=True); parser.add_argument("--output-dir", type=Path, required=True); parser.add_argument("--staging-dir", type=Path, default=None)
+    parser.add_argument("--workers", type=int, default=max(1, min(4, int(os.environ.get("CPU_CORES") or os.cpu_count() or 2) - 1)))
+    parser.add_argument("--limit-files", type=int, default=None)
+    parser.add_argument("--upload-repo", default=None); parser.add_argument("--upload-prefix", default="reports/decontam")
+    args = parser.parse_args(argv)
+    args.output_dir.mkdir(parents=True, exist_ok=True); staging = args.staging_dir or (args.output_dir / "_staging"); staging.mkdir(parents=True, exist_ok=True)
+    part_dir = args.output_dir / args.part; part_dir.mkdir(parents=True, exist_ok=True); matches_dir = part_dir / "matches"; matches_dir.mkdir(parents=True, exist_ok=True)
+    files = [f for f in args.files.split(",") if f]
+    if args.repo and args.prefix:
+        from huggingface_hub import HfApi
+
+        api = HfApi(); base = args.prefix.strip("/")
+        for attempt in range(5):
+            try:
+                entries = list(api.list_repo_tree(args.repo, path_in_repo=base, repo_type="dataset", recursive=True)); break
+            except Exception as error:  # noqa: BLE001
+                print(json.dumps({"event": "list_retry", "attempt": attempt + 1, "error": repr(error)[:160]}), flush=True); time.sleep(30 * (attempt + 1))
+        else:
+            raise RuntimeError("list_repo_tree failed")
+        files = sorted(e.path for e in entries if type(e).__name__ == "RepoFile" and fnmatch.fnmatch(e.path[len(base) + 1:], args.pattern))
+    if args.limit_files is not None:
+        files = files[: args.limit_files]
+    if not files:
+        raise FileNotFoundError("対象ファイルがありません")
+    config = {"text_column": args.text_column, "url_column": args.url_column, "patterns": args.patterns}
+    n_patterns = pq.ParquetFile(args.patterns).metadata.num_rows
+    tasks = [{"repo": args.repo, "path": f, "staging_dir": str(staging), "matches_dir": str(matches_dir)} for f in files]
+    print(json.dumps({"event": "start", "part": args.part, "files": len(tasks), "workers": args.workers, "patterns": n_patterns}), flush=True)
+    run_started = time.perf_counter(); results = []
+    with ProcessPoolExecutor(max_workers=max(1, min(args.workers, len(tasks))), initializer=_init, initargs=(config,)) as pool:
+        for r in pool.map(process_file, tasks):
+            results.append(r)
+            print(json.dumps({"event": "error" if "error" in r else "done", **{k: r.get(k) for k in ("path", "rows", "matched_docs", "seconds", "error")}}), flush=True)
+    ok = [r for r in results if "error" not in r]; errors = [r for r in results if "error" in r]
+    tot = Counter(); ptd = Counter(); pfd = Counter(); pfds = Counter(); pte: dict[str, set] = {}; pdocs: Counter = Counter()
+    for r in ok:
+        tot["rows"] += r["rows"]; tot["matched_docs"] += r["matched_docs"]
+        for k, v in r["per_task_docs"].items(): ptd[k] += v
+        for k, v in r["per_field_docs"].items(): pfd[k] += v
+        for k, v in r["per_field_docs_strong"].items(): pfds[k] += v
+        for k, v in r["per_task_examples"].items(): pte.setdefault(k, set()).update(v)
+        for k, v in r["pattern_docs"].items(): pdocs[int(k)] += v
+    import pyarrow as pa
+    pq.write_table(pa.table({"pattern_idx": list(pdocs.keys()), "doc_count": list(pdocs.values())}), part_dir / "pattern_docs.parquet", compression="zstd")
+    # 一致行をまとめる（部分ファイルは削除）
+    merged = part_dir / "matches.jsonl"
+    with merged.open("w", encoding="utf-8") as out:
+        for r in ok:
+            p = Path(r["matches_file"])
+            if p.exists():
+                out.write(p.read_text(encoding="utf-8")); p.unlink()
+    matches_dir.rmdir()
+    summary = {"version": VERSION, "part": args.part, "repo": args.repo, "prefix": args.prefix, "text_column": args.text_column, "patterns": n_patterns,
+               "finished_at_utc": datetime.now(timezone.utc).isoformat(), "files": len(files), "files_ok": len(ok), "files_failed": [{"path": r["path"], "error": r["error"]} for r in errors],
+               "totals": dict(tot), "per_task_docs": dict(ptd), "per_task_examples_matched": {k: len(v) for k, v in pte.items()}, "per_task_examples": {k: sorted(v)[:5000] for k, v in pte.items()},
+               "per_field_docs": dict(pfd), "per_field_docs_strong": dict(pfds), "seconds": round(time.perf_counter() - run_started, 1)}
+    (part_dir / f"{args.part}.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({"event": "finish", "part": args.part, "totals": summary["totals"], "per_task_docs": summary["per_task_docs"], "failed": len(errors), "seconds": summary["seconds"]}, ensure_ascii=False), flush=True)
+    if args.upload_repo:
+        from huggingface_hub import HfApi
+
+        api = HfApi()
+        for attempt in range(8):
+            try:
+                api.upload_folder(repo_id=args.upload_repo, repo_type="dataset", folder_path=str(part_dir), path_in_repo=f"{args.upload_prefix.strip('/')}/{args.part}", commit_message=f"decontam {args.part}")
+                print(json.dumps({"event": "uploaded", "path": f"{args.upload_prefix}/{args.part}"}), flush=True); break
+            except Exception as error:  # noqa: BLE001
+                wait = min(600, 60 * (attempt + 1)); print(json.dumps({"event": "upload_retry", "attempt": attempt + 1, "error": repr(error)[:200], "wait_s": wait}), flush=True); time.sleep(wait)
+        else:
+            raise SystemExit("upload failed")
+    if errors:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()