| """abeja-cc-ja 第5パス: 金融アフィリエイト・EC 商品ページ・未対応区分（秘密情報、機密・流出、非同意性的、海賊版、Web 定型、キーワード詰め込み）の除去、 |
| IP アドレスと認証情報値のマスキング、完全一致重複の除去（計画があれば）。入力 outputs_decontam/<dir>/<shard>/<shard>.parquet（url, content, perplexity）。 |
| |
| python tools/abeja_pass5.py --calibrate --files a.parquet,b.parquet # ローカル較正（規則別の件数と例） |
| python tools/abeja_pass5.py --repo Podtech/abeja-cc-ja-cleaned --source-prefix outputs_decontam --dir common_crawl_0 --output-root /work/out/common_crawl_0 --upload-repo ... --upload-prefix outputs_v5 |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import collections |
| import hashlib |
| import json |
| import os |
| import re |
| import shutil |
| import time |
| import traceback |
| from concurrent.futures import ProcessPoolExecutor |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from typing import Any |
|
|
| VERSION = "abeja-pass5/2026-09-09" |
| EXCLUDE_GENRES_DEFAULT = "diary_blog,affiliate,game,entertainment,ec_product" |
| CTA = ["口座開設", "公式サイト", "今なら", "キャンペーン", "キャッシュバック", "おすすめ", "ランキング", "比較", "申し込み", "申込", "限定", "最短", "無料", "詳しくはこちら", "こちらから", "登録はこちら", "特典", "ボーナス", "紹介コード", "招待コード", "アフィリエイト", "提携", "口コミ", "評判", "デメリット", "メリット"] |
| VERTICALS = { |
| "fx": ["FX", "外国為替証拠金", "為替差益", "スワップポイント", "通貨ペア", "ロスカット", "pips", "証拠金", "スプレッド", "レバレッジ", "ドル円", "米ドル/円", "海外FX", "自動売買", "デイトレード", "スキャルピング"], |
| "crypto": ["仮想通貨", "暗号資産", "ビットコイン", "BTC", "イーサリアム", "アルトコイン", "取引所", "ウォレット", "マイニング", "NFT", "エアドロップ", "草コイン", "ステーキング", "DeFi"], |
| "fund": ["投資信託", "NISA", "iDeCo", "つみたて", "積立投資", "信託報酬", "インデックスファンド", "米国株", "高配当", "証券口座", "楽天証券", "SBI証券", "資産運用", "ロボアド"], |
| "loan": ["カードローン", "キャッシング", "消費者金融", "借入", "即日融資", "審査", "借り換え", "おまとめ", "無利息", "プロミス", "アコム", "アイフル", "闇金", "ソフト闇金", "後払い", "現金化"], |
| "realestate": ["不動産投資", "ワンルーム", "利回り", "家賃収入", "マンション投資", "サブリース", "不動産クラウドファンディング", "太陽光投資"], |
| "beauty": ["脱毛", "美白", "シミ", "しわ", "たるみ", "毛穴", "エステ", "美容液", "化粧水", "サプリ", "ダイエット", "痩せ", "酵素", "プロテイン", "育毛", "薄毛", "AGA", "バストアップ", "ホワイトニング", "医療脱毛", "全身脱毛", "クリニック", "二重整形", "ヒアルロン酸"], |
| "jobs": ["転職エージェント", "転職サイト", "求人", "年収", "未経験", "派遣", "退職代行", "プログラミングスクール", "資格講座"], |
| "dating": ["婚活", "マッチングアプリ", "出会い", "結婚相談所", "パパ活", "セフレ"], |
| "utility": ["ウォーターサーバー", "マットレス", "光回線", "格安SIM", "ポケットWiFi", "引越し業者", "買取", "車査定", "太陽光", "宅配クリーニング", "食材宅配", "ハウスクリーニング"], |
| } |
| |
| STRONG_TERMS = { |
| "loan": {"カードローン", "キャッシング", "消費者金融", "即日融資", "無利息", "プロミス", "アコム", "アイフル", "闇金", "ソフト闇金", "後払い", "現金化", "おまとめ"}, |
| "jobs": {"転職エージェント", "転職サイト", "退職代行", "プログラミングスクール", "資格講座", "派遣"}, |
| "realestate": {"不動産投資", "サブリース", "不動産クラウドファンディング", "太陽光投資", "家賃収入", "マンション投資"}, |
| "fund": {"投資信託", "NISA", "iDeCo", "つみたて", "積立投資", "信託報酬", "インデックスファンド", "証券口座", "楽天証券", "SBI証券", "ロボアド"}, |
| "crypto": {"仮想通貨", "暗号資産", "ビットコイン", "BTC", "イーサリアム", "アルトコイン", "エアドロップ", "草コイン", "ステーキング", "DeFi", "NFT"}, |
| "utility": {"ウォーターサーバー", "光回線", "格安SIM", "ポケットWiFi", "車査定", "宅配クリーニング", "食材宅配", "ハウスクリーニング", "引越し業者"}, |
| "beauty": {"脱毛", "医療脱毛", "全身脱毛", "美容液", "サプリ", "育毛", "薄毛", "AGA", "バストアップ", "ホワイトニング", "二重整形", "ヒアルロン酸", "酵素", "プロテイン"}, |
| } |
| |
| RULE_MIN = {"fx": (1, 2), "crypto": (2, 2), "fund": (2, 2), "loan": (2, 2), "realestate": (2, 3), "beauty": (2, 3), "jobs": (2, 3), "dating": (2, 3), "utility": (2, 3)} |
| EC_CUES = ["カートに入れる", "カートに追加", "買い物かご", "在庫あり", "在庫なし", "送料無料", "税込", "税抜", "円（税込）", "円(税込)", "販売価格", "定価", "ポイント還元", "商品説明", "商品番号", "商品コード", "型番", "JAN", "数量", "ご注文", "お届け", "配送", "返品", "ギフト", "ラッピング", "メーカー希望小売価格", "セール", "アウトレット", "お気に入りに追加", "再入荷", "レビューを書く", "お客様の声", "SOLD OUT", "売り切れ", "入荷待ち"] |
| EC_HOST = re.compile(r"rakuten\.co\.jp|amazon\.co\.jp|shopping\.yahoo\.co\.jp|store\.shopping|mercari|zozo|yodobashi|biccamera|kakaku\.com|monotaro|askul|dmm\.com|/item/|/products?/|/goods/|/shop/|shop\.|store\.|cart|/product-", re.I) |
| PIRACY_SITES = ["漫画村", "漫画バンク", "anitube", "kissanime", "nyaa", "13dl", "manga1000", "manga1001", "hitomi.la", "rawdevart", "mangaraw", "torrent", "トレント", "海賊版", "違法アップロード", "違法ダウンロード"] |
| PIRACY_CUES = ["無料で読める", "全巻無料", "無料視聴", "無料で見る", "zip", "rar", "ダウンロード", "raw", "字幕付き 無料", "見放題 違法"] |
| NONCONSENT = ["盗撮", "隠し撮り", "リベンジポルノ", "流出動画", "流出画像", "流出した動画", "ハメ撮り", "無修正流出", "個人撮影"] |
| WEAK_PIRACY = {"torrent", "トレント"} |
| SEXUAL_TERMS_FILE = "abeja-cc-ja/src/wordlists/cooccurrence/ja_sexual_terms.txt" |
| CONFIDENTIAL = re.compile(r"社外秘|部外秘|関係者外秘|Confidential\s*[-–:]?\s*(?:Do not distribute|Internal use only)|INTERNAL USE ONLY|STRICTLY CONFIDENTIAL", re.I) |
| CRED_DUMP_LINE = re.compile(r"^[^\s@]+@[^\s@]+\.[a-z]{2,}\s*[:|;,\t ]\s*\S{6,}\s*$", re.I | re.M) |
| SECRET_STRONG = re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_\-]{35}|gh[pousr]_[A-Za-z0-9]{36,}|xox[baprs]-[0-9A-Za-z\-]{10,}|sk_live_[0-9a-zA-Z]{24,}") |
| SECRET_KV = re.compile(r"(?i)\b(api[_-]?key|secret[_-]?key|access[_-]?token|client[_-]?secret|auth[_-]?token)\b\s*[:=]\s*['\"]?([A-Za-z0-9_\-]{20,})") |
| PASSWORD_KV = re.compile(r"(?i)(password|passwd|pwd|パスワード|暗証番号)\s*[:=：]\s*['\"]?(?!\*+|●+|●|\*|x+\b|半角|英数|例|ここ)([^\s'\"、。，,]{6,32})") |
| BOILER = ["Cookieを使用", "Cookie を使用", "クッキーを使用", "Cookieの使用に同意", "cookieの利用に同意", "ページが見つかりません", "お探しのページ", "404 Not Found", "JavaScriptを有効", "JavaScript を有効", "JavaScriptが無効", "ブラウザの設定", "アクセスが集中", "メンテナンス中", "ページは移動", "削除された可能性"] |
| IPV4 = re.compile(r"(?<![\d.])((?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d))(?![\d.])") |
| _AUTO = None; _SEX = None; _ENC = None |
|
|
|
|
| def _boundary_ok(low: str, st: int, end: int, term: str) -> bool: |
| if not term.isascii(): return True |
| return not ((st > 0 and low[st - 1].isalnum()) or (end + 1 < len(low) and low[end + 1].isalnum())) |
|
|
|
|
| def _init(cfg: dict) -> None: |
| global _AUTO, _SEX, _ENC |
| import ahocorasick |
| a = ahocorasick.Automaton() |
| groups = {f"v:{k}": v for k, v in VERTICALS.items()}; groups["cta"] = CTA; groups["ec"] = EC_CUES; groups["pir_site"] = PIRACY_SITES; groups["pir_cue"] = PIRACY_CUES; groups["noncons"] = NONCONSENT; groups["boiler"] = BOILER |
| index: dict[str, set] = collections.defaultdict(set) |
| for g, terms in groups.items(): |
| for t in terms: index[t.casefold()].add(g) |
| for t, gs in index.items(): a.add_word(t, (t, tuple(gs))) |
| a.make_automaton(); _AUTO = a |
| sex = ahocorasick.Automaton() |
| for t in cfg.get("sexual_terms") or []: sex.add_word(t.casefold(), t) |
| sex.make_automaton(); _SEX = sex if cfg.get("sexual_terms") else None |
| if cfg.get("count_tokens"): |
| import tiktoken; _ENC = tiktoken.get_encoding("o200k_harmony") |
|
|
|
|
| def scan(text: str) -> dict[str, set]: |
| low = text.casefold(); found: dict[str, set] = collections.defaultdict(set) |
| for end, (term, gs) in _AUTO.iter(low): |
| st = end - len(term) + 1 |
| if not _boundary_ok(low, st, end, term): continue |
| for g in gs: found[g].add(term) |
| return found |
|
|
|
|
| def keyword_stuffing(text: str) -> tuple[bool, str]: |
| t = re.sub(r"\s+", "", text) |
| if len(t) < 600: return False, "" |
| c = collections.Counter(t[i:i + 4] for i in range(0, len(t) - 3)) |
| g, n = c.most_common(1)[0] |
| if n >= 25 and n * 4 / len(t) >= 0.12 and re.search(r"[^\W\d_]", g): return True, f"{g}×{n}" |
| return False, "" |
|
|
|
|
| def decide(url: str, text: str) -> tuple[list[str], dict, str, dict]: |
| """(除去理由の一覧, 詳細, マスキング後の本文, マスキング件数)""" |
| reasons: list[str] = []; info: dict = {}; f = scan(text) |
| cta = f.get("cta", set()) |
| for k in VERTICALS: |
| vt = f.get(f"v:{k}", set()) |
| strong = vt & STRONG_TERMS.get(k, vt) |
| min_terms, min_cta = RULE_MIN.get(k, (2, 3)) |
| if len(vt) >= min_terms and strong and len(cta) >= min_cta: |
| reasons.append(f"affiliate_{k}"); info[f"affiliate_{k}"] = {"terms": sorted(vt)[:6], "cta": sorted(cta)[:6]} |
| ec = f.get("ec", set()); host = bool(EC_HOST.search(url or "")) |
| if len(ec) >= 6 or (host and len(ec) >= 3): reasons.append("ec_product"); info["ec_product"] = {"cues": sorted(ec)[:8], "host": host} |
| ps, pc = f.get("pir_site", set()), f.get("pir_cue", set()) |
| strong_ps = ps - WEAK_PIRACY |
| if len(ps) >= 2 or (strong_ps and pc) or (ps and len(pc) >= 2): reasons.append("piracy"); info["piracy"] = {"sites": sorted(ps)[:4], "cues": sorted(pc)[:4]} |
| nc = f.get("noncons", set()) |
| if nc and _SEX is not None: |
| low = text.casefold(); sex_hits = {t for _, t in _SEX.iter(low)} - set(NONCONSENT) - {"性的", "性", "エロ"} |
| if len(sex_hits) >= 2: reasons.append("nonconsensual_sexual"); info["nonconsensual_sexual"] = {"terms": sorted(nc)[:4], "sexual": sorted(sex_hits)[:4]} |
| if SECRET_STRONG.search(text): reasons.append("secret_key"); info["secret_key"] = SECRET_STRONG.search(text).group(0)[:12] + "…" |
| dump = CRED_DUMP_LINE.findall(text) |
| if len(dump) >= 5: reasons.append("credential_dump"); info["credential_dump"] = {"lines": len(dump)} |
| m = CONFIDENTIAL.search(text) |
| if m: reasons.append("confidential_marker"); info["confidential_marker"] = m.group(0) |
| b = f.get("boiler", set()) |
| if len(text) < 1000 and len(b) >= 2: reasons.append("web_boilerplate"); info["web_boilerplate"] = sorted(b)[:5] |
| ks, kinfo = keyword_stuffing(text) |
| if ks: reasons.append("keyword_stuffing"); info["keyword_stuffing"] = kinfo |
| masks: dict[str, int] = {}; out = text |
| if not reasons: |
| out, n = IPV4.subn(lambda mm: mm.group(1) if mm.group(1).startswith(("10.", "127.", "192.168.", "0.", "255.")) or re.match(r"172\.(1[6-9]|2\d|3[01])\.", mm.group(1)) else "<IP>", out) |
| if n: masks["ip"] = n |
| out, n = SECRET_KV.subn(lambda mm: f"{mm.group(1)}=<SECRET>", out) |
| if n: masks["secret_kv"] = n |
| out, n = PASSWORD_KV.subn(lambda mm: f"{mm.group(1)}: <SECRET>", out) |
| if n: masks["password"] = n |
| return reasons, info, out, masks |
|
|
|
|
| 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 as e: |
| if k == attempts - 1: raise |
| time.sleep(20 * (k + 1)) |
|
|
|
|
| def process_shard(task: dict) -> dict: |
| import pyarrow as pa, pyarrow.parquet as pq |
| started = time.perf_counter(); shard = task["shard"] |
| try: |
| _init(task["cfg"]) |
| 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) |
| genre_of: dict[str, str] = {} |
| if task.get("features_path"): |
| fl = _fetch(task["repo"], task["features_path"], Path(task["staging_dir"])) if task.get("repo") else Path(task["features_path"]) |
| ft = pq.read_table(fl, columns=["content_sha1", "genre"]); genre_of = dict(zip(ft.column("content_sha1").to_pylist(), ft.column("genre").to_pylist())) |
| if task.get("repo"): Path(fl).unlink(missing_ok=True) |
| exclude_genres = set(task["cfg"].get("exclude_genres") or []) |
| 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) |
| dedup: set = set(task.get("dedup_rows") or []); reasons_c = collections.Counter(); masks_c = collections.Counter(); rows_in = 0; written = 0; tok_removed = 0; masked_docs = 0 |
| removed_f = (out_dir / "pass5_removed.jsonl").open("w", encoding="utf-8"); sha_list = [] |
| 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; url = d["url"][i] or ""; text = d["content"][i] or "" |
| if row in dedup: |
| reasons, info = ["exact_duplicate"], {"exact_duplicate": task.get("dedup_info", {}).get(row)}; out = text; masks = {} |
| else: |
| reasons, info, out, masks = decide(url, text) |
| g = genre_of.get(hashlib.sha1(text.encode("utf-8")).hexdigest()) if genre_of else None |
| if g in exclude_genres: |
| reasons.append(f"genre_{g}"); info[f"genre_{g}"] = True; out = text; masks = {} |
| elif genre_of and g is None: reasons_c["_features_unmatched"] += 1 |
| if reasons: |
| for r in reasons: reasons_c[r] += 1 |
| reasons_c["_removed"] += 1 |
| if _ENC is not None: tok_removed += len(_ENC.encode(text, disallowed_special=())) |
| removed_f.write(json.dumps({"row_index": row, "reasons": reasons, "info": info, "url": url, "content": text, "perplexity": d.get("perplexity", [None] * n)[i]}, ensure_ascii=False, default=str) + "\n") |
| else: |
| keep_idx.append(i); new_content[i] = out |
| if masks: masked_docs += 1; masks_c.update(masks) |
| sha_list.append(hashlib.sha1(out.encode("utf-8")).digest()) |
| if keep_idx: |
| cols = {} |
| for name in pf.schema_arrow.names: |
| vals = new_content if name == "content" else d[name] |
| cols[name] = pa.array([vals[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() |
| pq.write_table(pa.table({"sha1": pa.array(sha_list, pa.binary(20))}), out_dir / "pass5_sha1.parquet") |
| check = pq.ParquetFile(out_dir / f"{shard}.parquet"); assert check.metadata.num_rows == written == rows_in - reasons_c["_removed"], "row count mismatch" |
| summary = {"version": VERSION, "dir": task["config"], "shard": shard, "rows_in": rows_in, "rows_removed": reasons_c.pop("_removed", 0), "rows_out": written, "features_unmatched": reasons_c.pop("_features_unmatched", 0), "features_rows": len(genre_of), "removed_by_reason": dict(reasons_c), |
| "masked_docs": masked_docs, "masks": dict(masks_c), "tokens_removed": tok_removed if _ENC is not None else None, "dedup_rows_planned": len(dedup), "compression": codec, "seconds": round(time.perf_counter() - started, 1), "finished_at_utc": datetime.now(timezone.utc).isoformat()} |
| (out_dir / "pass5_summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") |
| if task.get("repo"): Path(local).unlink(missing_ok=True) |
| return summary |
| except Exception as error: |
| return {"shard": shard, "error": repr(error), "traceback": traceback.format_exc()} |
|
|
|
|
| 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: |
| 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], cfg: dict, limit: int | None, features: list[str] | None = None) -> None: |
| import pyarrow.parquet as pq |
| _init(cfg); c = collections.Counter(); ex = collections.defaultdict(list); n = 0; masks_c = collections.Counter(); hosts = collections.defaultdict(collections.Counter); excl = set(cfg.get("exclude_genres") or []) |
| for fi, f in enumerate(files): |
| pf = pq.ParquetFile(f); genre_of = {} |
| if features: |
| ft = pq.read_table(features[fi], columns=["content_sha1", "genre"]); genre_of = dict(zip(ft.column("content_sha1").to_pylist(), ft.column("genre").to_pylist())) |
| for batch in pf.iter_batches(batch_size=2048, columns=["url", "content"]): |
| for url, text in zip(batch.column("url").to_pylist(), batch.column("content").to_pylist()): |
| n += 1; reasons, info, out, masks = decide(url or "", text or "") |
| g = genre_of.get(hashlib.sha1((text or "").encode("utf-8")).hexdigest()) if genre_of else None |
| if g in excl: reasons.append(f"genre_{g}"); info[f"genre_{g}"] = True |
| for r in reasons: |
| c[r] += 1; hosts[r][re.sub(r"^https?://([^/]+).*", r"\1", url or "")] += 1 |
| if len(ex[r]) < 4: ex[r].append((url[:60], json.dumps(info.get(r), ensure_ascii=False)[:100], (text or "")[:120].replace("\n", " "))) |
| if reasons: c["_removed"] += 1 |
| masks_c.update(masks) |
| if limit and n >= limit: break |
| if limit and n >= limit: break |
| only_genre = sum(1 for _ in []) |
| print(json.dumps({"docs": n, "removed": c.pop("_removed", 0), "by_reason": dict(c), "masks": dict(masks_c)}, ensure_ascii=False)) |
| for r, lst in ex.items(): |
| print(f"== {r} ({c[r]}, {c[r]/n:.3%}) hosts {hosts[r].most_common(3)}") |
| for e in lst: print(" ", e[0], "|", e[1], "|", e[2]) |
|
|
|
|
| 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("--limit", type=int, default=None) |
| parser.add_argument("--repo", default=None); parser.add_argument("--source-prefix", default="outputs_decontam"); 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("--plan", default=None, help="dedup 計画 parquet（dir, shard, row_index, kept_shard, kept_row_index）") |
| parser.add_argument("--sexual-terms", default=None); parser.add_argument("--count-tokens", action="store_true"); parser.add_argument("--limit-shards", type=int, default=None) |
| parser.add_argument("--features-prefix", default=None, help="第2パス出力の接頭辞（<dir>/<shard>/features.parquet からジャンルを引く）"); parser.add_argument("--features-files", default="", help="較正用: --files と同順の features.parquet") |
| parser.add_argument("--exclude-genres", default=EXCLUDE_GENRES_DEFAULT) |
| parser.add_argument("--upload-repo", default=None); parser.add_argument("--upload-prefix", default="outputs_v5"); 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) |
| sexual = [l.strip() for l in open(args.sexual_terms, encoding="utf-8") if l.strip() and not l.startswith("#")] if args.sexual_terms else [] |
| cfg = {"sexual_terms": sexual, "count_tokens": args.count_tokens, "exclude_genres": [g for g in args.exclude_genres.split(",") if g]} |
| if args.calibrate: |
| calibrate([f for f in args.files.split(",") if f], cfg, args.limit, [f for f in args.features_files.split(",") if f] or None); return |
| from huggingface_hub import HfApi |
| api = HfApi(token=os.environ.get("HF_TOKEN")) |
| shards = sorted({e.path.split("/")[-1] for e in api.list_repo_tree(args.repo, path_in_repo=f"{args.source_prefix}/{args.dir}", repo_type="dataset", recursive=False)}) |
| if args.limit_shards: shards = shards[: args.limit_shards] |
| existing = 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: existing = set() |
| plan: dict[str, dict[int, Any]] = {} |
| if args.plan: |
| import pyarrow.parquet as pq |
| t = pq.read_table(args.plan).filter(pq.compute.equal(pq.read_table(args.plan).column("dir"), args.dir)) if False else pq.read_table(args.plan) |
| import pyarrow.compute as pc |
| t = t.filter(pc.equal(t.column("dir"), args.dir)) |
| for sh, row, ks, kr in zip(t.column("shard").to_pylist(), t.column("row_index").to_pylist(), t.column("kept_shard").to_pylist(), t.column("kept_row_index").to_pylist()): |
| plan.setdefault(sh, {})[int(row)] = {"kept_shard": ks, "kept_row_index": kr} |
| tasks = [{"repo": args.repo, "path": f"{args.source_prefix}/{args.dir}/{sh}/{sh}.parquet", "features_path": f"{args.features_prefix}/{args.dir}/{sh}/features.parquet" if args.features_prefix else None, "shard": sh, "config": args.dir, "output_root": str(args.output_root), "staging_dir": str(args.staging_dir), "cfg": cfg, |
| "dedup_rows": list(plan.get(sh, {}).keys()), "dedup_info": plan.get(sh, {})} for sh in shards if sh not in existing] |
| print(json.dumps({"event": "start", "dir": args.dir, "shards": len(shards), "skipped_existing": len(shards) - len(tasks), "dedup_rows": sum(len(v) for v in plan.values())}), flush=True) |
| pending = []; failed = [] |
| 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)[:600], 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")}}, 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() |
|
|
