| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import random |
| from collections import Counter |
| from dataclasses import asdict |
| from pathlib import Path |
| from typing import Any |
|
|
| import numpy as np |
| from tqdm import tqdm |
|
|
| from kawk50m.cli import configure_utf8_stdio |
| from kawk50m.io import discover_paths, iter_documents |
| from kawk50m.text import ( |
| FilterConfig, |
| measure_text, |
| quality_score, |
| rejection_reason, |
| ) |
|
|
|
|
| METRIC_FIELDS = ( |
| "characters", |
| "hangul_visible_ratio", |
| "hangul_letter_ratio", |
| "digit_ratio", |
| "symbol_ratio", |
| "unique_line_ratio", |
| "unique_word_ratio", |
| "short_line_ratio", |
| "list_line_ratio", |
| "table_line_ratio", |
| "boilerplate_hits_per_1k", |
| "repeated_character_run", |
| ) |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser( |
| description="Audit Korean corpus quality and write deterministic samples." |
| ) |
| parser.add_argument("--input", nargs="+", required=True) |
| parser.add_argument("--output-dir", required=True) |
| parser.add_argument("--limit", type=int, default=100_000) |
| parser.add_argument("--sample-size", type=int, default=200) |
| parser.add_argument("--lowest-quality-size", type=int, default=200) |
| parser.add_argument("--seed", type=int, default=42) |
| return parser.parse_args() |
|
|
|
|
| def quantiles(values: list[float]) -> dict[str, float]: |
| if not values: |
| return {} |
| result = np.quantile( |
| np.asarray(values, dtype=np.float64), |
| [0.0, 0.01, 0.05, 0.25, 0.50, 0.75, 0.95, 0.99, 1.0], |
| ) |
| names = ("min", "p01", "p05", "p25", "p50", "p75", "p95", "p99", "max") |
| return {name: float(value) for name, value in zip(names, result)} |
|
|
|
|
| def compact_row( |
| document: dict[str, Any], |
| *, |
| score: float, |
| reason: str | None, |
| metrics: Any, |
| ) -> dict[str, Any]: |
| return { |
| "id": document.get("id"), |
| "source": document.get("source"), |
| "url": document.get("url"), |
| "quality_score": round(score, 6), |
| "rejection_reason": reason, |
| "metrics": { |
| field: getattr(metrics, field) |
| for field in METRIC_FIELDS |
| }, |
| "text": document["text"], |
| } |
|
|
|
|
| def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None: |
| with path.open("w", encoding="utf-8") as handle: |
| for row in rows: |
| handle.write(json.dumps(row, ensure_ascii=False) + "\n") |
|
|
|
|
| def main() -> None: |
| configure_utf8_stdio() |
| args = parse_args() |
| if args.limit <= 0: |
| raise ValueError("--limit must be positive") |
| if args.sample_size < 0 or args.lowest_quality_size < 0: |
| raise ValueError("sample sizes must be non-negative") |
|
|
| paths = discover_paths(args.input) |
| if not paths: |
| raise FileNotFoundError("No supported audit inputs were found") |
|
|
| output_dir = Path(args.output_dir) |
| output_dir.mkdir(parents=True, exist_ok=True) |
| expected_outputs = ( |
| output_dir / "audit_summary.json", |
| output_dir / "random_sample.jsonl", |
| output_dir / "lowest_quality.jsonl", |
| ) |
| for path in expected_outputs: |
| if path.exists(): |
| raise FileExistsError( |
| f"{path} already exists. Choose a new audit output directory." |
| ) |
|
|
| rng = random.Random(args.seed) |
| filter_config = FilterConfig() |
| counters: Counter[str] = Counter() |
| sources: Counter[str] = Counter() |
| values: dict[str, list[float]] = { |
| field: [] for field in (*METRIC_FIELDS, "quality_score") |
| } |
| sample: list[dict[str, Any]] = [] |
| lowest: list[dict[str, Any]] = [] |
|
|
| documents = iter_documents(paths) |
| for index, document in enumerate( |
| tqdm(documents, total=args.limit, unit="docs"), |
| start=1, |
| ): |
| if index > args.limit: |
| break |
| metrics = measure_text(document["text"]) |
| reason = rejection_reason( |
| document["text"], filter_config, metrics=metrics |
| ) |
| score = quality_score(metrics, filter_config) |
| row = compact_row( |
| document, |
| score=score, |
| reason=reason, |
| metrics=metrics, |
| ) |
|
|
| counters["documents"] += 1 |
| counters["accepted" if reason is None else f"rejected_{reason}"] += 1 |
| sources[str(document.get("source") or "unknown")] += 1 |
| for field in METRIC_FIELDS: |
| values[field].append(float(getattr(metrics, field))) |
| values["quality_score"].append(score) |
|
|
| if len(sample) < args.sample_size: |
| sample.append(row) |
| elif args.sample_size: |
| replacement = rng.randrange(index) |
| if replacement < args.sample_size: |
| sample[replacement] = row |
|
|
| if args.lowest_quality_size: |
| lowest.append(row) |
| lowest.sort(key=lambda item: item["quality_score"]) |
| if len(lowest) > args.lowest_quality_size: |
| lowest.pop() |
|
|
| summary = { |
| "inputs": [str(path) for path in paths], |
| "limit": args.limit, |
| "seed": args.seed, |
| "filter": asdict(filter_config), |
| "counts": dict(sorted(counters.items())), |
| "sources": dict(sources.most_common()), |
| "quantiles": { |
| field: quantiles(field_values) |
| for field, field_values in values.items() |
| }, |
| } |
|
|
| with (output_dir / "audit_summary.json").open( |
| "w", encoding="utf-8" |
| ) as handle: |
| json.dump(summary, handle, ensure_ascii=False, indent=2) |
| handle.write("\n") |
| write_jsonl(output_dir / "random_sample.jsonl", sample) |
| write_jsonl(output_dir / "lowest_quality.jsonl", lowest) |
| print(json.dumps(summary, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
