File size: 6,187 Bytes
cf8c8d4
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
"""Choose which training records to spend compute on. Writes a canonical JSONL subset.

Modes (combine them by running one after another):
  sieve    drop records whose label is structurally broken: empty, unclosed tags or math, ragged tables,
           a decoding loop in the label (FireRed-OCR's rule-based "sieve"; DADC's consistency filters).
  hard     keep the records the current model gets most wrong, from a common.vlm_infer predictions file.
           Records above --max-cer are dropped as likely label noise, not hard cases (FireRed routes
           those to review; MinerU-Diffusion's hard-sample stage and SP-DocReader also train on residual errors).
  entropy  keep the records where the model is least certain of the ground-truth tokens (mean token
           entropy under teacher forcing). FD-RL picks its RL set the same way from rollouts
           (top 50% of 16k candidates); teacher forcing is a cheaper proxy that needs no sampling.
  balance  cap each source (and level) so no single source dominates; rare sources keep everything
           (FireRed-OCR's stratified sampling).

    python -m common.select_data sieve   --input train.jsonl --out train.clean.jsonl
    python -m common.select_data hard    --input train.jsonl --preds runs/ovisocr3_train.jsonl --keep 0.3 --out hard.jsonl
    python -m common.select_data entropy --input train.jsonl --model data/models/OvisOCR3 --adapter runs/lora --keep 0.5 --out grpo.jsonl
    python -m common.select_data balance --input train.jsonl --per-source 5000 --out balanced.jsonl
"""
import argparse
import random
from collections import defaultdict

import torch

from .rewards import r_closure, r_table
from .score import cer, has_loop, norm
from .vlm_utils import read_jsonl, write_jsonl, resolve_prompt


def sieve(rows):
    kept, why = [], defaultdict(int)
    for r in rows:
        t = r.get("text", "")
        reason = ("empty" if not t.strip() else "unclosed" if r_closure(t) < 1 else
                  "ragged_table" if r_table(t) < 1 else "loop" if has_loop(t) else None)
        if reason:
            why[reason] += 1
        else:
            kept.append(r)
    print("dropped:", dict(why))
    return kept


def hard(rows, preds_path, keep, max_cer, min_cer):
    preds = {p["id"]: p for p in read_jsonl(preds_path) if "pred" in p}
    scored = []
    for r in rows:
        p = preds.get(r["id"])
        if p is None:
            continue
        c = cer(norm(p["pred"]), norm(r["text"]))
        if min_cer <= c <= max_cer:
            scored.append((c, r))
    scored.sort(key=lambda x: -x[0])
    n = int(len(scored) * keep) if keep <= 1 else int(keep)
    print(f"{len(preds)} predictions, {len(scored)} within CER [{min_cer}, {max_cer}], keeping {n}")
    return [r for _, r in scored[:n]]


@torch.no_grad()
def entropy(rows, model_path, adapter, keep, max_pixels, prompt):
    from .vlm_utils import Codec, load_policy, with_answer
    model, processor, _ = load_policy(model_path, adapter, 8)
    model.eval()
    device = next(model.parameters()).device
    codec = Codec(processor, prompt, max_pixels)
    scored = []
    for r in rows:
        enc = codec.prompt_inputs(r, device)
        y = codec.answer_ids(r["text"])
        inputs, L0 = with_answer(enc, y)
        keep_idx = torch.arange(L0 - 1, L0 - 1 + len(y), device=device)
        logp = torch.log_softmax(model(**inputs, logits_to_keep=keep_idx, use_cache=False).logits[0].float(), -1)
        h = float(-(logp.exp() * logp).sum(-1).mean())
        scored.append((h, r))
    scored.sort(key=lambda x: -x[0])
    n = int(len(scored) * keep) if keep <= 1 else int(keep)
    print(f"mean entropy: top {scored[0][0]:.3f}, median {scored[len(scored) // 2][0]:.3f}; keeping {n}")
    return [r for _, r in scored[:n]]


def balance(rows, per_source, seed):
    groups = defaultdict(list)
    for r in rows:
        groups[(r.get("source"), r.get("level"))].append(r)
    rng = random.Random(seed)
    out = []
    for key, rs in sorted(groups.items(), key=lambda kv: str(kv[0])):
        rng.shuffle(rs)
        out += rs[:per_source]
        print(f"{key}: {len(rs)} -> {min(len(rs), per_source)}")
    rng.shuffle(out)
    return out


def main(argv=None):
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("mode", choices=["sieve", "hard", "entropy", "balance"])
    ap.add_argument("--input", required=True, help="canonical JSONL")
    ap.add_argument("--out", required=True)
    ap.add_argument("--preds", help="hard: predictions JSONL from common.vlm_infer on the same records")
    ap.add_argument("--keep", type=float, default=0.3, help="fraction (<=1) or count (>1) to keep")
    ap.add_argument("--max-cer", type=float, default=0.6, help="hard: above this, treat as label noise")
    ap.add_argument("--min-cer", type=float, default=0.0)
    ap.add_argument("--model", help="entropy: model path")
    ap.add_argument("--adapter", help="entropy: LoRA adapter of the model to score with")
    ap.add_argument("--max-pixels", type=int, default=1280 * 1280)
    ap.add_argument("--prompt", help="prompt for page records (default: the page prompt from data_prep); lines keep the line prompt")
    ap.add_argument("--prompt-file", help="read the page prompt from a file (e.g. a model's prompts/*.txt)")
    ap.add_argument("--per-source", type=int, default=5000, help="balance: cap per (source, level)")
    ap.add_argument("--seed", type=int, default=0)
    a = ap.parse_args(argv)
    a.prompt = resolve_prompt(a.prompt, a.prompt_file)

    rows = read_jsonl(a.input)
    if a.mode == "sieve":
        out = sieve(rows)
    elif a.mode == "hard":
        if not a.preds:
            ap.error("hard needs --preds")
        out = hard(rows, a.preds, a.keep, a.max_cer, a.min_cer)
    elif a.mode == "entropy":
        if not a.model:
            ap.error("entropy needs --model")
        out = entropy(rows, a.model, a.adapter, a.keep, a.max_pixels, a.prompt)
    else:
        out = balance(rows, a.per_source, a.seed)
    write_jsonl(a.out, out)
    print(f"{len(rows)} -> {len(out)} records: {a.out}")


if __name__ == "__main__":
    main()