| """2種類の語群が近接して現れる文書を検出する近接共起規則。 |
| |
| 単語リストの密度（同一カテゴリ3語以上）では判別できない次の2種類を扱う。 |
| |
| * 未成年を示す語 × 性的な語（監査項目5「未成年が登場する文脈は0件」） |
| * 違法行為の対象語 × 手引きを示す語（監査項目8「違法行為の手引き」） |
| |
| 規則は ``wordlists/cooccurrence/rules.json`` に定義し、語リストは同じ |
| ディレクトリの1行1語ファイルから読む。一致した文書は削除対象になると同時に、 |
| 全件が目視確認用の ``cooccurrence_review.jsonl`` へ書き出される。 |
| """ |
|
|
| from __future__ import annotations |
|
|
| import bisect |
| import json |
| from dataclasses import dataclass |
| from pathlib import Path |
| from typing import Any |
|
|
| from textmatch import compile_trie_pattern, normalize, read_terms |
|
|
|
|
| @dataclass(frozen=True) |
| class CooccurrenceRule: |
| name: str |
| category: str |
| label_ja: str |
| terms_a: tuple[str, ...] |
| terms_b: tuple[str, ...] |
| window: int |
| description_ja: str = "" |
| terms_a_file: str = "" |
| terms_b_file: str = "" |
|
|
|
|
| def load_rules(path: Path) -> list[CooccurrenceRule]: |
| """規則定義JSONと語リストを読む。語リストのパスはJSONからの相対パス。""" |
|
|
| spec = json.loads(path.read_text(encoding="utf-8")) |
| base = path.parent |
| rules: list[CooccurrenceRule] = [] |
| for item in spec["rules"]: |
| terms_a = read_terms(base / item["terms_a"]) |
| terms_b = read_terms(base / item["terms_b"]) |
| if not terms_a or not terms_b: |
| raise ValueError(f"規則 {item['name']} の語リストが空です: {item['terms_a']}, {item['terms_b']}") |
| rules.append( |
| CooccurrenceRule( |
| name=item["name"], |
| category=item["category"], |
| label_ja=item["label_ja"], |
| terms_a=tuple(dict.fromkeys(terms_a)), |
| terms_b=tuple(dict.fromkeys(terms_b)), |
| window=int(item.get("window", 100)), |
| description_ja=item.get("description_ja", ""), |
| terms_a_file=item["terms_a"], |
| terms_b_file=item["terms_b"], |
| ) |
| ) |
| return rules |
|
|
|
|
| class CooccurrenceDetector: |
| """各規則について、語群Aと語群Bの出現位置が window 文字以内の組を探す。""" |
|
|
| def __init__(self, rules: list[CooccurrenceRule]) -> None: |
| self.rules = rules |
| self._patterns = [ |
| ( |
| rule, |
| compile_trie_pattern(sorted(rule.terms_a, key=lambda t: (-len(t), t))), |
| compile_trie_pattern(sorted(rule.terms_b, key=lambda t: (-len(t), t))), |
| ) |
| for rule in rules |
| ] |
|
|
| def describe(self) -> list[dict[str, Any]]: |
| return [ |
| { |
| "name": rule.name, |
| "category": rule.category, |
| "label_ja": rule.label_ja, |
| "window": rule.window, |
| "terms_a_file": rule.terms_a_file, |
| "terms_a_count": len(rule.terms_a), |
| "terms_b_file": rule.terms_b_file, |
| "terms_b_count": len(rule.terms_b), |
| "description_ja": rule.description_ja, |
| } |
| for rule in self.rules |
| ] |
|
|
| def detect(self, text: Any, max_pairs: int = 10, excerpt_margin: int = 60) -> list[dict[str, Any]]: |
| normalized = normalize(text) |
| if not normalized: |
| return [] |
| results: list[dict[str, Any]] = [] |
| for rule, pattern_a, pattern_b in self._patterns: |
| a_hits = [(found.start(), found.group(0)) for found in pattern_a.finditer(normalized)] |
| if not a_hits: |
| continue |
| b_hits = [(found.start(), found.group(0)) for found in pattern_b.finditer(normalized)] |
| if not b_hits: |
| continue |
| b_positions = [position for position, _ in b_hits] |
| pairs: list[dict[str, Any]] = [] |
| for a_position, a_term in a_hits: |
| low = bisect.bisect_left(b_positions, a_position - rule.window) |
| high = bisect.bisect_right(b_positions, a_position + rule.window) |
| for b_position, b_term in b_hits[low:high]: |
| pairs.append( |
| { |
| "a": a_term, |
| "b": b_term, |
| "distance": abs(a_position - b_position), |
| "position": min(a_position, b_position), |
| } |
| ) |
| if not pairs: |
| continue |
| pairs.sort(key=lambda pair: (pair["position"], pair["distance"])) |
| first = pairs[0] |
| start = max(0, first["position"] - excerpt_margin) |
| end = min(len(normalized), first["position"] + rule.window + excerpt_margin) |
| results.append( |
| { |
| "rule": rule.name, |
| "category": rule.category, |
| "label_ja": rule.label_ja, |
| "pair_count": len(pairs), |
| "pairs": pairs[:max_pairs], |
| "excerpt": normalized[start:end].replace("\n", " "), |
| } |
| ) |
| return results |
|
|
