| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sqlite3 |
| from collections import Counter |
| from collections import deque |
| from concurrent.futures import ProcessPoolExecutor |
| from collections.abc import Iterable, Iterator |
| from dataclasses import asdict |
| from pathlib import Path |
| from typing import Any |
|
|
| from tqdm import tqdm |
|
|
| from kawk50m.cli import configure_utf8_stdio |
| from kawk50m.io import ShardedJsonlWriter, discover_paths, iter_documents |
| from kawk50m.text import ( |
| FilterConfig, |
| canonical_hash, |
| measure_text, |
| near_duplicate_signature, |
| normalize_text, |
| quality_score, |
| rejection_reason, |
| split_for_hash, |
| ) |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description=( |
| "Clean, quality-filter, exactly/approximately deduplicate, " |
| "and split Korean documents." |
| ) |
| ) |
| parser.add_argument( |
| "--input", |
| nargs="+", |
| required=True, |
| help="Input files, directories, or glob patterns (.jsonl/.txt, optionally .gz).", |
| ) |
| parser.add_argument("--output-dir", default="data/clean") |
| parser.add_argument("--text-field", default="text") |
| parser.add_argument("--txt-mode", choices=("line", "document"), default="line") |
| parser.add_argument("--documents-per-shard", type=int, default=50_000) |
| parser.add_argument("--validation-ratio", type=float, default=0.002) |
| parser.add_argument("--test-ratio", type=float, default=0.001) |
| parser.add_argument("--seed", type=int, default=42) |
| parser.add_argument("--limit", type=int, default=None) |
| parser.add_argument( |
| "--workers", |
| type=int, |
| default=1, |
| help="Process normalization/filtering/hash batches in parallel.", |
| ) |
| parser.add_argument( |
| "--worker-batch-size", |
| type=int, |
| default=64, |
| help="Documents submitted to each filtering worker at once.", |
| ) |
|
|
| parser.add_argument("--min-chars", type=int, default=300) |
| parser.add_argument("--max-chars", type=int, default=100_000) |
| parser.add_argument("--min-hangul-chars", type=int, default=50) |
| parser.add_argument("--min-hangul-ratio", type=float, default=0.70) |
| parser.add_argument("--min-hangul-visible-ratio", type=float, default=0.55) |
| parser.add_argument("--max-digit-ratio", type=float, default=0.08) |
| parser.add_argument("--max-symbol-ratio", type=float, default=0.15) |
| parser.add_argument("--max-url-per-word", type=float, default=0.01) |
| parser.add_argument("--min-unique-line-ratio", type=float, default=0.70) |
| parser.add_argument("--min-unique-word-ratio", type=float, default=0.20) |
| parser.add_argument("--max-short-line-ratio", type=float, default=0.50) |
| parser.add_argument("--max-list-line-ratio", type=float, default=0.25) |
| parser.add_argument("--max-table-line-ratio", type=float, default=0.10) |
| parser.add_argument( |
| "--max-boilerplate-hits-per-1k", type=float, default=1.5 |
| ) |
| parser.add_argument("--max-repeated-character-run", type=int, default=20) |
| parser.add_argument("--max-code-line-ratio", type=float, default=0.25) |
| parser.add_argument("--max-code-math-char-ratio", type=float, default=0.15) |
| parser.add_argument("--min-quality-score", type=float, default=0.70) |
| parser.add_argument( |
| "--disable-near-dedupe", |
| action="store_true", |
| help="Disable bottom-k paragraph/chunk near-duplicate sketches.", |
| ) |
| parser.add_argument( |
| "--keep-html", action="store_true", help="Do not remove residual HTML tags." |
| ) |
| parser.add_argument( |
| "--keep-pii", |
| action="store_true", |
| help="Do not replace email, phone, and resident-registration patterns.", |
| ) |
| return parser.parse_args() |
|
|
|
|
| def process_document( |
| document: dict[str, Any], |
| filter_config: FilterConfig, |
| ) -> tuple[dict[str, Any], str, str | None, str | None, str | None, float]: |
| text = normalize_text( |
| document["text"], |
| strip_html=filter_config.strip_html, |
| mask_pii=filter_config.mask_pii, |
| ) |
| metrics = measure_text(text) |
| reason = rejection_reason(text, filter_config, metrics=metrics) |
| document_hash = canonical_hash(text) if reason is None else None |
| near_signature = ( |
| near_duplicate_signature(text) if reason is None else None |
| ) |
| score = quality_score(metrics, filter_config) |
| return document, text, reason, document_hash, near_signature, score |
|
|
|
|
| def process_batch( |
| documents: list[dict[str, Any]], |
| filter_config: FilterConfig, |
| ) -> list[ |
| tuple[dict[str, Any], str, str | None, str | None, str | None, float] |
| ]: |
| return [process_document(document, filter_config) for document in documents] |
|
|
|
|
| def document_batches( |
| documents: Iterable[dict[str, Any]], |
| *, |
| batch_size: int, |
| limit: int | None, |
| ) -> Iterator[list[dict[str, Any]]]: |
| batch: list[dict[str, Any]] = [] |
| seen = 0 |
| for document in documents: |
| if limit is not None and seen >= limit: |
| break |
| batch.append(document) |
| seen += 1 |
| if len(batch) >= batch_size: |
| yield batch |
| batch = [] |
| if batch: |
| yield batch |
|
|
|
|
| def processed_documents( |
| documents: Iterable[dict[str, Any]], |
| *, |
| filter_config: FilterConfig, |
| workers: int, |
| batch_size: int, |
| limit: int | None, |
| ) -> Iterator[ |
| tuple[dict[str, Any], str, str | None, str | None, str | None, float] |
| ]: |
| batches = document_batches(documents, batch_size=batch_size, limit=limit) |
| if workers == 1: |
| for batch in batches: |
| yield from process_batch(batch, filter_config) |
| return |
|
|
| max_pending = workers * 2 |
| pending: deque[Any] = deque() |
| with ProcessPoolExecutor(max_workers=workers) as executor: |
| for batch in batches: |
| pending.append(executor.submit(process_batch, batch, filter_config)) |
| if len(pending) >= max_pending: |
| yield from pending.popleft().result() |
| while pending: |
| yield from pending.popleft().result() |
|
|
|
|
| def ensure_safe_output(output_dir: Path) -> None: |
| existing = [ |
| *output_dir.glob("train-*.jsonl"), |
| *output_dir.glob("validation-*.jsonl"), |
| *output_dir.glob("test-*.jsonl"), |
| ] |
| if existing: |
| names = ", ".join(path.name for path in existing[:3]) |
| raise FileExistsError( |
| f"{output_dir} already contains generated shards ({names}). " |
| "Choose a new output directory to avoid overwriting data." |
| ) |
|
|
|
|
| def main() -> None: |
| configure_utf8_stdio() |
| args = parse_args() |
| paths = discover_paths(args.input) |
| if not paths: |
| raise FileNotFoundError("No supported input files were found") |
| if args.documents_per_shard <= 0: |
| raise ValueError("--documents-per-shard must be positive") |
| if args.workers <= 0: |
| raise ValueError("--workers must be positive") |
| if args.worker_batch_size <= 0: |
| raise ValueError("--worker-batch-size must be positive") |
|
|
| filter_config = FilterConfig( |
| min_chars=args.min_chars, |
| max_chars=args.max_chars, |
| min_hangul_chars=args.min_hangul_chars, |
| min_hangul_letter_ratio=args.min_hangul_ratio, |
| min_hangul_visible_ratio=args.min_hangul_visible_ratio, |
| max_digit_ratio=args.max_digit_ratio, |
| max_symbol_ratio=args.max_symbol_ratio, |
| max_url_per_word=args.max_url_per_word, |
| min_unique_line_ratio=args.min_unique_line_ratio, |
| min_unique_word_ratio=args.min_unique_word_ratio, |
| max_short_line_ratio=args.max_short_line_ratio, |
| max_list_line_ratio=args.max_list_line_ratio, |
| max_table_line_ratio=args.max_table_line_ratio, |
| max_boilerplate_hits_per_1k=args.max_boilerplate_hits_per_1k, |
| max_repeated_character_run=args.max_repeated_character_run, |
| max_code_line_ratio=args.max_code_line_ratio, |
| max_code_math_char_ratio=args.max_code_math_char_ratio, |
| min_quality_score=args.min_quality_score, |
| strip_html=not args.keep_html, |
| mask_pii=not args.keep_pii, |
| ) |
|
|
| output_dir = Path(args.output_dir) |
| output_dir.mkdir(parents=True, exist_ok=True) |
| ensure_safe_output(output_dir) |
|
|
| dedupe_path = output_dir / "exact_dedupe.sqlite3" |
| if dedupe_path.exists(): |
| raise FileExistsError( |
| f"{dedupe_path} already exists. Choose a new output directory." |
| ) |
|
|
| counters: Counter[str] = Counter() |
| writers = { |
| split: ShardedJsonlWriter( |
| output_dir, split, documents_per_shard=args.documents_per_shard |
| ) |
| for split in ("train", "validation", "test") |
| } |
|
|
| connection = sqlite3.connect(dedupe_path) |
| connection.execute("PRAGMA journal_mode=WAL") |
| connection.execute("PRAGMA synchronous=NORMAL") |
| connection.execute("CREATE TABLE hashes (hash TEXT PRIMARY KEY)") |
| if not args.disable_near_dedupe: |
| connection.execute( |
| "CREATE TABLE near_signatures (signature TEXT PRIMARY KEY)" |
| ) |
|
|
| try: |
| documents = iter_documents( |
| paths, text_field=args.text_field, txt_mode=args.txt_mode |
| ) |
| processed = processed_documents( |
| documents, |
| filter_config=filter_config, |
| workers=args.workers, |
| batch_size=args.worker_batch_size, |
| limit=args.limit, |
| ) |
| for index, ( |
| document, |
| text, |
| reason, |
| document_hash, |
| near_signature, |
| score, |
| ) in enumerate( |
| tqdm(processed, total=args.limit, unit="docs"), |
| start=1, |
| ): |
| counters["seen"] += 1 |
| if reason is not None: |
| counters[f"rejected_{reason}"] += 1 |
| else: |
| assert document_hash is not None |
| cursor = connection.execute( |
| "INSERT OR IGNORE INTO hashes(hash) VALUES (?)", (document_hash,) |
| ) |
| if cursor.rowcount == 0: |
| counters["rejected_exact_duplicate"] += 1 |
| else: |
| if not args.disable_near_dedupe: |
| assert near_signature is not None |
| near_cursor = connection.execute( |
| "INSERT OR IGNORE INTO near_signatures(signature) " |
| "VALUES (?)", |
| (near_signature,), |
| ) |
| if near_cursor.rowcount == 0: |
| counters["rejected_near_duplicate"] += 1 |
| continue |
| split = split_for_hash( |
| document_hash, |
| validation_ratio=args.validation_ratio, |
| test_ratio=args.test_ratio, |
| seed=args.seed, |
| ) |
| output_row = { |
| "id": document["id"], |
| "text": text, |
| "source": document["source"], |
| "url": document["url"], |
| "license": document["license"], |
| "sha256": document_hash, |
| "quality_score": round(score, 6), |
| } |
| writers[split].write(output_row) |
| counters[f"accepted_{split}"] += 1 |
| counters["accepted_characters"] += len(text) |
| counters["accepted_quality_score_micros"] += round( |
| score * 1_000_000 |
| ) |
|
|
| if index % 10_000 == 0: |
| connection.commit() |
| connection.commit() |
| finally: |
| connection.close() |
| for writer in writers.values(): |
| writer.close() |
|
|
| stats = { |
| "inputs": [str(path) for path in paths], |
| "filter": asdict(filter_config), |
| "near_dedupe": { |
| "enabled": not args.disable_near_dedupe, |
| "method": "bottom-k paragraph/chunk sketch", |
| }, |
| "split": { |
| "train": 1.0 - args.validation_ratio - args.test_ratio, |
| "validation": args.validation_ratio, |
| "test": args.test_ratio, |
| "seed": args.seed, |
| }, |
| "counts": dict(sorted(counters.items())), |
| } |
| stats_path = output_dir / "prepare_stats.json" |
| with stats_path.open("w", encoding="utf-8") as handle: |
| json.dump(stats, handle, ensure_ascii=False, indent=2) |
| handle.write("\n") |
| print(json.dumps(stats["counts"], ensure_ascii=False, indent=2)) |
| print(f"Stats: {stats_path}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
