| """シャードごとの shard_summary.json を集約し、全件の件数・母数・内訳を出す。 |
| |
| ローカルのディレクトリ（``--root``）か、HF データセット（``--repo`` と ``--prefix``、 |
| ``outputs/**/shard_summary.json`` を取得）を入力にできる。``--expected-inputs`` に |
| 入力データセット名を渡すと、入力シャード一覧と突き合わせて未処理シャードを列挙する。 |
| |
| uv run python abeja-cc-ja/src/aggregate_summaries.py --repo Podtech/abeja-cc-ja-cleaned --prefix outputs \\ |
| --expected-inputs Podtech/abeja-cc-ja-filtered --output dataset_summary.json |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| from collections import Counter, defaultdict |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| def _load_local(root: Path, marker: str = "shard_summary.json") -> list[dict[str, Any]]: |
| return [json.loads(p.read_text(encoding="utf-8")) for p in sorted(root.rglob(marker))] |
|
|
|
|
| def _load_repo(repo_id: str, prefix: str, marker: str = "shard_summary.json") -> list[dict[str, Any]]: |
| from huggingface_hub import snapshot_download |
|
|
| local = snapshot_download(repo_id, repo_type="dataset", allow_patterns=[f"{prefix.strip('/')}/**/{marker}"]) |
| return _load_local(Path(local) / prefix.strip("/"), marker) |
|
|
|
|
| def aggregate_noise(summaries: list[dict[str, Any]]) -> dict[str, Any]: |
| """第2パス（noise_summary.json）の集約。パターン別・項目別・理由別に合算する。""" |
|
|
| total = Counter() |
| by_reason = Counter() |
| by_item: dict[str, Counter] = defaultdict(Counter) |
| by_pattern: dict[str, Counter] = defaultdict(Counter) |
| pattern_meta: dict[str, dict[str, Any]] = {} |
| thresholds: Counter = Counter() |
| shards = [] |
| for s in summaries: |
| shards.append(s["shard"]) |
| n = s["noise"] |
| total["input_rows"] += s["input_rows"] |
| for k in ("records_deleted", "records_retained", "records_modified", "records_newline_joined", "chars_before", "chars_after_retained"): |
| total[k] += n.get(k) or 0 |
| if n.get("tokens_after_retained"): |
| total["tokens_after_retained"] += n["tokens_after_retained"] |
| for k, v in n["records_deleted_by_reason"].items(): |
| by_reason[k] += v |
| for item, v in n["by_item"].items(): |
| for k, x in v.items(): |
| by_item[item][k] += x |
| for p in n["patterns"]: |
| pattern_meta[p["id"]] = {"item": p["item"], "action": p["action"]} |
| for k in ("records_detected", "occurrences", "lines_removed", "replacements"): |
| by_pattern[p["id"]][k] += p[k] |
| thresholds[json.dumps(n["thresholds"], sort_keys=True, ensure_ascii=False)] += 1 |
| return { |
| "aggregated_at_utc": datetime.now(timezone.utc).isoformat(), |
| "stage": "noise", |
| "shards": len(shards), |
| "totals": dict(total), |
| "deletion_rate": round(total["records_deleted"] / max(1, total["input_rows"]), 5), |
| "records_deleted_by_reason": dict(by_reason), |
| "by_item": {k: dict(v) for k, v in sorted(by_item.items(), key=lambda kv: int(kv[0]))}, |
| "by_pattern": {k: {**pattern_meta[k], **dict(v)} for k, v in sorted(by_pattern.items(), key=lambda kv: (pattern_meta[kv[0]]["item"], kv[0]))}, |
| "thresholds": [json.loads(k) for k in thresholds], |
| "shard_list": sorted(shards), |
| } |
|
|
|
|
| def _expected_shards(repo_id: str) -> set[str]: |
| from huggingface_hub import HfApi |
|
|
| return {Path(p).stem for p in HfApi().list_repo_files(repo_id, repo_type="dataset") if p.endswith(".parquet")} |
|
|
|
|
| def aggregate(summaries: list[dict[str, Any]]) -> dict[str, Any]: |
| total = Counter() |
| by_reason = Counter() |
| by_category_match = Counter() |
| by_category_deleted = Counter() |
| by_source_matched = Counter() |
| by_source_deleted = Counter() |
| by_rule = Counter() |
| pii_records = Counter() |
| pii_replacements = Counter() |
| seconds = Counter() |
| policies = Counter() |
| versions = Counter() |
| shards = [] |
| for s in summaries: |
| shards.append(s["shard"]) |
| versions[s.get("pipeline_version", "?")] += 1 |
| total["input_rows"] += s["input_rows"] |
| total["toxic_deleted"] += s["toxic"]["records_deleted"] |
| total["toxic_retained"] += s["toxic"]["records_retained"] |
| total["pii_records_with_replacement"] += s["pii"]["records_with_replacement"] |
| total["pii_total_replacements"] += s["pii"]["total_replacements"] |
| total["final_rows"] += s["output"]["final_rows"] |
| for k, v in s["toxic"]["records_deleted_by_reason"].items(): |
| by_reason[k] += v |
| for c, v in s["toxic"]["by_category"].items(): |
| by_category_match[c] += v["records_with_match"] |
| by_category_deleted[c] += v["records_deleted"] |
| for name, v in (s["toxic"].get("domain_blocklist_by_source") or {}).items(): |
| by_source_matched[name] += v.get("records_matched", 0) |
| by_source_deleted[name] += v.get("records_deleted", 0) |
| for name, v in (s["toxic"].get("cooccurrence_by_rule") or {}).items(): |
| by_rule[name] += v.get("records_matched", 0) |
| for t, v in s["pii"]["by_type"].items(): |
| pii_records[t] += v["records_with_match"] |
| pii_replacements[t] += v["replacement_count"] |
| for k, v in s["seconds"].items(): |
| seconds[k] += v |
| p = s["pii"].get("policy") or {} |
| policies[f"{p.get('action')}|{p.get('approved_by')}|{p.get('approved_on')}|{p.get('status')}"] += 1 |
| n = total["input_rows"] or 1 |
| return { |
| "aggregated_at_utc": datetime.now(timezone.utc).isoformat(), |
| "shards": len(shards), |
| "pipeline_versions": dict(versions), |
| "totals": dict(total), |
| "toxic": { |
| "deletion_rate": round(total["toxic_deleted"] / n, 5), |
| "records_deleted_by_reason": dict(by_reason), |
| "by_category": {c: {"records_with_match": by_category_match[c], "records_deleted": by_category_deleted[c]} for c in sorted(set(by_category_match) | set(by_category_deleted))}, |
| "domain_blocklist_by_source": {k: {"records_matched": by_source_matched[k], "records_deleted": by_source_deleted[k]} for k in sorted(by_source_matched)}, |
| "cooccurrence_by_rule": dict(by_rule), |
| }, |
| "pii": { |
| "denominator_records": total["toxic_retained"], |
| "records_with_replacement_rate": round(total["pii_records_with_replacement"] / max(1, total["toxic_retained"]), 5), |
| "by_type": {t: {"records_with_match": pii_records[t], "replacement_count": pii_replacements[t]} for t in sorted(pii_records)}, |
| "policies": dict(policies), |
| }, |
| "seconds": dict(seconds), |
| "shard_list": sorted(shards), |
| } |
|
|
|
|
| def main(argv: list[str] | None = None) -> None: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| source = parser.add_mutually_exclusive_group(required=True) |
| source.add_argument("--root", type=Path) |
| source.add_argument("--repo") |
| parser.add_argument("--prefix", default="outputs") |
| parser.add_argument("--expected-inputs", default=None, help="入力データセット（未処理シャードの検出用）") |
| parser.add_argument("--stage", choices=("full", "noise"), default="full", help="noise: 第2パスの noise_summary.json を集約") |
| parser.add_argument("--output", type=Path, required=True) |
| args = parser.parse_args(argv) |
| marker = "noise_summary.json" if args.stage == "noise" else "shard_summary.json" |
| summaries = _load_local(args.root, marker) if args.root else _load_repo(args.repo, args.prefix, marker) |
| result = aggregate_noise(summaries) if args.stage == "noise" else aggregate(summaries) |
| if args.expected_inputs: |
| expected = _expected_shards(args.expected_inputs) |
| done = set(result["shard_list"]) |
| result["completeness"] = {"expected": len(expected), "done": len(done & expected), "missing": sorted(expected - done)[:200], "missing_count": len(expected - done), "unexpected": sorted(done - expected)[:50]} |
| args.output.write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") |
| t = result["totals"] |
| if args.stage == "noise": |
| print(json.dumps({"shards": result["shards"], "input_rows": t.get("input_rows"), "noise_deleted": t.get("records_deleted"), "retained": t.get("records_retained"), |
| "modified": t.get("records_modified"), "completeness": result.get("completeness", {}).get("missing_count")}, ensure_ascii=False)) |
| else: |
| print(json.dumps({"shards": result["shards"], "input_rows": t.get("input_rows"), "toxic_deleted": t.get("toxic_deleted"), "final_rows": t.get("final_rows"), |
| "pii_replacements": t.get("pii_total_replacements"), "completeness": result.get("completeness", {}).get("missing_count")}, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
