orbitkit 0.9.22__tar.gz → 0.9.24__tar.gz

{orbitkit-0.9.22/orbitkit.egg-info → orbitkit-0.9.24}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.2
 Name: orbitkit
-Version: 0.9.22
+Version: 0.9.24
 Summary: This project is only for Orbit Tech internal use.
 Home-page: https://github.com/clown-0726/orbitkit
 Author: Lilu Cao
@@ -45,7 +45,6 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
-Dynamic: license-file
 Dynamic: maintainer
 Dynamic: maintainer-email
 Dynamic: platform

orbitkit-0.9.24/orbitkit/VERSION

@@ -0,0 +1 @@
+0.9.24

{orbitkit-0.9.22 → orbitkit-0.9.24}/orbitkit/pdf_quality/parse_record.py

@@ -15,8 +15,8 @@
     parsing_tool_ext      工具专属：mineru 用
                           {"mode", "vlm_rd_rate", "vlm_rd_threshold",
                            "bbox_error_rate", "bbox_error_threshold",
-                           "vlm_rd_samples", "fallback_lang", "fallback_method",
-                           "fallback"}
+                           "vlm_rd_samples", "vlm_artifact_samples",
+                           "fallback_lang", "fallback_method", "fallback"}
 
 质量闸门（三道，任一超标即未过；失败码按下面的优先级取第一个超标的）：
     1. ``self_heal_error_rate > self_heal_threshold``（坏块率）→ 30007，可兜底重投
@@ -35,6 +35,10 @@
 文本片段）：判废只给一个率时，「预定 0.05 是否合理」无法复核，因为无法区分
 真退化和页眉/表头那种正常重复。没命中时不写这个键。
 
+``vlm_artifact_samples`` 同理，是几条被 ``drop_vlm_artifacts`` 丢弃的块（页码 /
+命中短语 / 截断片段）：坏块率超阀时能核「是真幻觉还是误伤正文」，也是提炼新
+anchor 的原料。没丢过不写这个键。
+
 ``fallback`` 是兜底结果（:class:`FallbackTrace`，一个对象）：没兜过不写这个键。
 其它字段只描述**最终采用**的那份产出 —— 兜底重投了但没救回、保留首轮结论
 时，``mode`` 仍是首轮引擎，只有这里能看出「试过、没成」及原因。
@@ -252,6 +256,8 @@ def build_parse_record(
     }
     if samples:
         ext["vlm_rd_samples"] = [dict(s) for s in samples]
+    if stats.artifact_samples:
+        ext["vlm_artifact_samples"] = [dict(s) for s in stats.artifact_samples]
     if fallback_lang:
         ext["fallback_lang"] = fallback_lang
     if fallback_method:
@@ -269,4 +275,4 @@ def build_parse_record(
         bbox_error_threshold=bbox_error_threshold,
         degenerate_samples=samples,
         parsing_tool_ext=ext,
-    )
+    )

{orbitkit-0.9.22 → orbitkit-0.9.24}/orbitkit/pdf_validator/__init__.py

@@ -34,6 +34,7 @@ from .filters.repeated_text import (
     trim_repeated_text,
 )
 from .pipeline import (
+    ARTIFACT_SAMPLE_LIMIT,
     DEGENERATE_SAMPLE_LIMIT,
     BlockFilter,
     DropHook,
@@ -66,6 +67,7 @@ __all__ = [
     "SequenceFilter",
     "DropHook",
     "FilterStats",
+    "ARTIFACT_SAMPLE_LIMIT",
     "DEGENERATE_SAMPLE_LIMIT",
     "Sample",
     "apply_block_filters",

{orbitkit-0.9.22 → orbitkit-0.9.24}/orbitkit/pdf_validator/filters/drop_vlm_artifacts.py

@@ -25,45 +25,82 @@ mineru VLM 偶发把训练时的 chain-of-thought / 评估文本当成"识别结
    **anchor 短语** —— 单次命中即丢弃。anchor 必须是"真实文档绝不
    出现"的措辞，零误报。
 
-判定流程：先查 anchor（单次命中即 drop）；再查 soft list（≥2 命中即 drop）。
+判定流程：先查 anchor（单次命中即 drop）；再查 soft list（≥2 个**不同短语**
+命中、且其中至少 1 个是**强短语**即 drop）。
+
+软短语分强 / 弱：
+
+- 强 = 自指 / 评估措辞，真实文档几乎不出现（"Ground Truth"、"hallucinated"、
+  "OCR output"…）；
+- 弱 = 真实文档里常见的措辞（"Rule 13.25A"、"inconsistent with"——港交所公告、
+  合同、法律条款里成对出现是常态）。弱短语只能给强短语"补票"，两个弱短语同现
+  不判死。
+
+"不同短语"按**短语（正则）**计数，不按匹配到的字符串：``rule 13`` 与 ``rule 17``
+是同一条短语命中两次，只算 1。
 """
 
 import re
-from typing import Optional
+from typing import List, Optional
 
 # Anchor 短语：真实文档不会出现的 VLM-only 自述句式。单次命中即丢弃。
 # 添加新 anchor 前必须 grep 历史归档样本（>10k PDFs）确认零命中。
 _VLM_ANCHOR_PHRASES = [
     r"\bThe image contains? no text\b",
+    r"\bThe OCR has hallucinated\b",
+    r"\binconsistent with the Ground Truth\b",
+    r"\bThe provided OCR (?:content|result|output)\b",
+    r"\bUNDERSCORE & LINE RULES\b",
 ]
 
-# 软阈值短语：自指 / 评估 / 规则引用。单条可能在真实文档出现，
-# 需 ≥ _MIN_HITS 个不同短语共同命中才丢。
-_VLM_PHRASES = [
+# 强软短语：自指 / 评估措辞。
+_VLM_STRONG_PHRASES = [
     r"\bGround Truth\b",
-    r"\bOCR (?:result|content|output|has|must)\b",
+    r"\bOCR (?:result|content|output)\b",
+    r"\bOCR (?:has|must)\b",
     r"\bviolating the rule\b",
     r"\bhallucinat(?:ed|ing|ion)\b",
-    r"\bRule \d+",
-    r"\binconsistent with\b",
     r"\bplaceholder underscore\b",
     r"\bprovided OCR\b",
     r"\bstylistic line\b",
 ]
 
+# 弱软短语：真实文档常见，只能配合强短语凑数。
+_VLM_WEAK_PHRASES = [
+    r"\bRule \d+",
+    r"\binconsistent with\b",
+]
+
 _VLM_ANCHOR_RE = re.compile("|".join(_VLM_ANCHOR_PHRASES), re.IGNORECASE)
-_VLM_RE = re.compile("|".join(_VLM_PHRASES), re.IGNORECASE)
+_VLM_STRONG_RES = [re.compile(p, re.IGNORECASE) for p in _VLM_STRONG_PHRASES]
+_VLM_WEAK_RES = [re.compile(p, re.IGNORECASE) for p in _VLM_WEAK_PHRASES]
 _MIN_HITS = 2  # 软阈值：不同短语命中数
 _MIN_TEXT_LEN = 50  # 短文本不可能塞下 2 个不同短语
 
 
-def drop_vlm_artifacts(block: dict) -> Optional[dict]:
-    text = block.get("sentence") or ""
+def vlm_artifact_hits(text: str) -> List[str]:
+    """判为 VLM 幻觉时命中的短语（每条短语取第 1 次匹配的原文），未判中返回空列表。
+
+    供 filter 本身与丢弃样本记录（``x_parse_record.vlm_artifact_samples``）共用，
+    保证"为什么被丢"与"是否被丢"是同一套判定。
+    """
     if len(text) < _MIN_TEXT_LEN:
-        return block
-    if _VLM_ANCHOR_RE.search(text):
-        return None
-    hits = {m.group(0).lower() for m in _VLM_RE.finditer(text)}
+        return []
+    anchor = _VLM_ANCHOR_RE.search(text)
+    if anchor:
+        return [anchor.group(0)]
+    strong = [m.group(0) for m in (r.search(text) for r in _VLM_STRONG_RES) if m]
+    if not strong:
+        return []
+    weak = [m.group(0) for m in (r.search(text) for r in _VLM_WEAK_RES) if m]
+    hits = strong + weak
     if len(hits) >= _MIN_HITS:
+        return hits
+    return []
+
+
+def drop_vlm_artifacts(block: dict) -> Optional[dict]:
+    text = block.get("sentence") or ""
+    if vlm_artifact_hits(text):
         return None
-    return block
+    return block

{orbitkit-0.9.22 → orbitkit-0.9.24}/orbitkit/pdf_validator/filters/repeated_text.py

@@ -32,6 +32,19 @@ VLM/OCR 偶发在一个 block 里把某个短语连续复读很多次，例如::
 filter**，因此质量闸门的复读退化率始终反映真实情况。它同时给出每个退化块的
 **命中详情**（复读短语 / 重复次数 / 文本片段），进 ``x_parse_record`` 后
 「退化率 0.054 该不该判死」才成为可复核的判断，而不是只有一个数字。
+
+**不算复读的重复**（表格 / 图表 markdown 里成行出现是常态，不是模型退化）：
+
+1. markdown 表格分隔行 ``| --- | --- | --- |``——语法而非内容，整行不参与判定；
+2. 占位符 / 空值 token（``-`` ``—`` ``na`` ``N/A`` ``none`` ``|`` 纯标点等）
+   对检测**透明**：既不计入短语，也不打断短语；
+3. 复读短语必须含至少一个**实词**（≥2 个拉丁字母，或 ≥1 个汉字 / 假名 / 谚文），
+   纯数字、纯符号的重复（``0 0 0 0``、``... ... ...``）不算。CJK 按**单字**算实词：
+   韩文按音节、VLM 退化时按单字吐（``的 的 的``、``의 이 의 이``），都是真复读。
+
+**token 内复读**：同一字符在一个 token 里连续 ≥ ``_MIN_CHAR_RUN`` 次（``5000000…``、
+``————…``）没有空白，按词切不出重复；切词时把这种连续段拆成逐字 token，走同一套
+结构检测（不受实词 / 占位符约束），trim 后只剩首次出现的那个字符。
 """
 
 from __future__ import annotations
@@ -57,6 +70,29 @@ _MIN_BLOCK_WORDS = 4
 
 _WORD_RE = re.compile(r"\S+")
 
+# markdown 表格分隔行：| --- | :---: | ---: |（也允许无首尾竖线）
+_MD_SEPARATOR_LINE_RE = re.compile(r"^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$")
+
+# 占位符 / 空值 token（小写比较）：表格里成行出现是常态，对复读检测透明
+_PLACEHOLDER_TOKENS = frozenset(
+    {
+        "na", "n/a", "n.a.", "n.a", "nan", "none", "non", "null", "nil",
+        "nm", "n.m.", "tbd", "tba", "n/d", "nd", "无", "暂无", "不适用",
+        "0", "0.0", "0.00", "0%", "0.0%", "0.00%",
+    }
+)
+
+# 实词：≥2 个连续字母（拉丁 / 西里尔 / 带重音等），或 ≥1 个 CJK 字符（汉字 / 假名 /
+# 谚文音节）——CJK 单字就是词，不能要求 ≥2。
+_REAL_WORD_RE = re.compile(
+    r"[^\W\d_]{2,}"
+    r"|[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uac00-\ud7af\uf900-\ufaff\U00020000-\U0002ffff]"
+)
+
+# token 内同一字符连续这么多次算退化（一个 "5000000000" 的真实数字也就 10 个 0）
+_MIN_CHAR_RUN = 20
+_CHAR_RUN_RE = re.compile(r"(.)\1{%d,}" % (_MIN_CHAR_RUN - 1))
+
 # 样本片段截断长度：只为让人判断「是真复读还是页眉/表头」，不做内容留存
 _SAMPLE_CHARS = 160
 
@@ -78,6 +114,69 @@ def _tokenize(text: str) -> Tuple[List[str], List[Tuple[int, int]]]:
     return words, spans
 
 
+def _is_placeholder(word: str) -> bool:
+    """占位符 / 空值 / 纯标点 token：对复读检测透明。"""
+    if not any(ch.isalnum() for ch in word):
+        return True  # 纯符号：| - — … / * ○ √ × ...
+    return word.lower() in _PLACEHOLDER_TOKENS
+
+
+def _content_tokens(text: str) -> Tuple[List[str], List[Tuple[int, int]]]:
+    """复读检测用的词序列：剔除 markdown 分隔行与占位符 token。
+
+    返回的 spans 仍是**原串**字符区间，trim 据此在原串上挖段；被剔除的 token
+    不出现在序列里，因此既不计入短语也不打断短语。
+    """
+    words: List[str] = []
+    spans: List[Tuple[int, int]] = []
+    offset = 0
+    for line in text.splitlines(keepends=True):
+        if not _MD_SEPARATOR_LINE_RE.match(line):
+            for m in _WORD_RE.finditer(line):
+                word = m.group(0)
+                if _CHAR_RUN_RE.search(word):
+                    _split_char_runs(word, offset + m.start(), words, spans)
+                    continue
+                if _is_placeholder(word):
+                    continue
+                words.append(word)
+                spans.append((offset + m.start(), offset + m.end()))
+        offset += len(line)
+    return words, spans
+
+
+def _split_char_runs(
+    word: str, base: int, words: List[str], spans: List[Tuple[int, int]]
+) -> None:
+    """把含同字符连续段的 token 拆成：前缀 / 逐字的连续段 / 后缀（可多段）。
+
+    连续段的字符不走占位符过滤：``0``、``-`` 在普通位置是占位符，连写二十个就是退化。
+    """
+    pos = 0
+    for m in _CHAR_RUN_RE.finditer(word):
+        if m.start() > pos:
+            words.append(word[pos : m.start()])
+            spans.append((base + pos, base + m.start()))
+        for k in range(m.start(), m.end()):
+            words.append(word[k])
+            spans.append((base + k, base + k + 1))
+        pos = m.end()
+    if pos < len(word):
+        words.append(word[pos:])
+        spans.append((base + pos, base + len(word)))
+
+
+def _has_real_word(phrase: Sequence[str]) -> bool:
+    return any(_REAL_WORD_RE.search(w) for w in phrase)
+
+
+def _counts_as_repeat(phrase: Sequence[str], reps: int) -> bool:
+    """短语含实词，或是单字符连续 ≥ ``_MIN_CHAR_RUN`` 次（token 内复读拆出来的形态）。"""
+    if _has_real_word(phrase):
+        return True
+    return len(phrase) == 1 and len(phrase[0]) == 1 and reps >= _MIN_CHAR_RUN
+
+
 def _find_runaway_repeats(
     words: List[str], *, max_n: int, min_reps: int
 ) -> List[Tuple[int, int, int]]:
@@ -99,7 +198,7 @@ def _find_runaway_repeats(
                 while j + n <= n_words and words[j : j + n] == words[i : i + n]:
                     reps += 1
                     j += n
-                if reps >= min_reps:
+                if reps >= min_reps and _counts_as_repeat(words[i : i + n], reps):
                     candidates.append((reps * n, i, n))
                     reps_of[(i, n)] = reps
                 i = j  # 跳过整段，避免重复检测子段
@@ -139,7 +238,7 @@ def has_runaway_repetition(
     只判定、不改文本，供统计「退化块占比」用。短于 ``min_words`` 的文本一律
     返回 ``False``（真实短句可能有正常重复）。
     """
-    words, _ = _tokenize(text or "")
+    words, _ = _content_tokens(text or "")
     if len(words) < min_words:
         return False
     return bool(_find_runaway_repeats(words, max_n=max_n, min_reps=min_reps))
@@ -215,7 +314,7 @@ def find_degenerate_blocks(blocks: Sequence[dict]) -> Dict[int, Sample]:
     found: Dict[int, Sample] = {}
     for i, b in enumerate(blocks):
         text = b.get("sentence") or ""
-        words, spans = _tokenize(text)
+        words, spans = _content_tokens(text)
         if len(words) < _MIN_WORDS:
             continue
         run = _find_runaway_repeat(words, max_n=_MAX_N, min_reps=_MIN_REPS)
@@ -297,7 +396,7 @@ def trim_repeated_text(block: dict) -> Optional[dict]:
     （可能是合法用词），删掉其余重复。
     """
     text = block.get("sentence") or ""
-    words, spans = _tokenize(text)
+    words, spans = _content_tokens(text)
     if len(words) < _MIN_WORDS:
         return block
 
@@ -321,7 +420,7 @@ def trim_repeated_text(block: dict) -> Optional[dict]:
 def drop_repeated_text(block: dict) -> Optional[dict]:
     """复读段主导整块（覆盖词数占比 ≥ 阈值）时整块丢弃，否则保留。"""
     text = block.get("sentence") or ""
-    words, _spans = _tokenize(text)
+    words, _spans = _content_tokens(text)
     if len(words) < _MIN_WORDS:
         return block
 
@@ -332,4 +431,4 @@ def drop_repeated_text(block: dict) -> Optional[dict]:
     covered = sum(n * reps for _start, n, reps in runs)
     if covered / len(words) >= _DROP_COVER_FRACTION:
         return None
-    return block
+    return block

{orbitkit-0.9.22 → orbitkit-0.9.24}/orbitkit/pdf_validator/pipeline.py

@@ -28,10 +28,15 @@ from dataclasses import dataclass, field
 from typing import Callable, Dict, List, Optional, Tuple
 
 from .filters.drop_invalid_bbox import has_bbox_error
+from .filters.drop_vlm_artifacts import drop_vlm_artifacts, vlm_artifact_hits
 from .filters.repeated_text import Sample, find_degenerate_blocks
 
 # x_parse_record 里最多带几条退化样本（够人工判断形态，不把 JSONB 当内容库）
 DEGENERATE_SAMPLE_LIMIT = 3
+# 同上：最多带几条被 drop_vlm_artifacts 丢弃的块样本（供复核假阳 / 提炼新 anchor）
+ARTIFACT_SAMPLE_LIMIT = 3
+_ARTIFACT_SNIPPET_CHARS = 200
+_VLM_ARTIFACT_FILTER = drop_vlm_artifacts.__name__
 
 log = logging.getLogger(__name__)
 
@@ -61,6 +66,9 @@ class FilterStats:
       （超阀 → 30005）
     - ``degenerate_samples``：最多 ``DEGENERATE_SAMPLE_LIMIT`` 条命中详情（复读
       短语 / 重复次数 / 截断的文本片段），让 ``vlm_rd_rate`` 可人工复核。
+    - ``artifact_samples``：最多 ``ARTIFACT_SAMPLE_LIMIT`` 条被 ``drop_vlm_artifacts``
+      丢弃的块（页码 / 命中短语 / 截断的文本片段），让坏块率可人工复核：是真
+      幻觉还是被误伤的正文。
     """
 
     total_in: int = 0
@@ -68,6 +76,7 @@ class FilterStats:
     bbox_error: int = 0
     degenerate: int = 0
     degenerate_samples: List[Sample] = field(default_factory=list)
+    artifact_samples: List[Sample] = field(default_factory=list)
 
     @property
     def dropped_total(self) -> int:
@@ -94,6 +103,20 @@ def collect_stats(blocks: List[Block], stats: FilterStats) -> FilterStats:
     return stats
 
 
+def _record_artifact_sample(block: Block, stats: FilterStats) -> None:
+    if len(stats.artifact_samples) >= ARTIFACT_SAMPLE_LIMIT:
+        return
+    text = block.get("sentence") or ""
+    page = block.get("page")
+    stats.artifact_samples.append(
+        {
+            "page": page if isinstance(page, int) else None,
+            "hits": " | ".join(vlm_artifact_hits(text)),
+            "snippet": text[:_ARTIFACT_SNIPPET_CHARS],
+        }
+    )
+
+
 def apply_block_filters(
     blocks: List[Block],
     pages: List[Page],
@@ -152,6 +175,8 @@ def apply_block_filters(
             name = dropped_by or "anonymous"
             if stats is not None:
                 stats.dropped[name] = stats.dropped.get(name, 0) + 1
+                if name == _VLM_ARTIFACT_FILTER:
+                    _record_artifact_sample(b, stats)
             if on_drop is not None:
                 try:
                     on_drop(name, str(b.get("type") or ""))
@@ -191,4 +216,4 @@ def apply_block_filters(
         )
         rebuilt_pages.append(new_p)
 
-    return surviving, rebuilt_pages
+    return surviving, rebuilt_pages

{orbitkit-0.9.22 → orbitkit-0.9.24/orbitkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.2
 Name: orbitkit
-Version: 0.9.22
+Version: 0.9.24
 Summary: This project is only for Orbit Tech internal use.
 Home-page: https://github.com/clown-0726/orbitkit
 Author: Lilu Cao
@@ -45,7 +45,6 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
-Dynamic: license-file
 Dynamic: maintainer
 Dynamic: maintainer-email
 Dynamic: platform

orbitkit-0.9.22/orbitkit/VERSION

@@ -1 +0,0 @@
-0.9.22