kafm' blog kafm' blog 2026-04-06T06:27:03.000Z https://www.kafm.eu.org/ kafm Hexo 书生大模型公式识别打榜赛参赛记录 https://www.kafm.eu.org/record/LLM/%E4%B9%A6%E7%94%9F%E5%A4%A7%E6%A8%A1%E5%9E%8B%E5%85%AC%E5%BC%8F%E8%AF%86%E5%88%AB%E6%89%93%E6%A6%9C%E8%B5%9B%E5%8F%82%E8%B5%9B%E8%AE%B0%E5%BD%95/ 2026-03-05T06:43:54.000Z 2026-04-06T06:27:03.000Z 参赛记录

本文记录参加书生大模型社区比赛的一些过程。

比赛简介

本次比赛是上海 AI Lab 举办的书生大模型实战营（第六期）的社区活动，在算力平台 d.run 上使用沐曦算力，通过微调 VLM 等方法识别输入的公式图片，输出对应的 LaTex 文本。限定使用 InternVL3.5-1B 模型。

之前也有过类似比赛，实战营（第五期）举办了论文分类打榜赛。微调 LLM 对论文摘要进行学科分类。

任务

具体来说，输入图片均为 texlive 渲染得到的 LaTex 公式图片，输出应为对应的 LaTex 公式文本。
例如对于输入：
image
期望的输出：

1
\sum_{i=1}^{\infty} \frac{1}{i^2} = \frac{\pi^2}{6} \quad \text{and} \quad \left\| \mathbf{A} \right\| = \sqrt{\lambda_{\max}(\mathbf{A}^T\mathbf{A})} \quad \text{where} \quad \mathbf{A} = \begin{bmatrix} \int_{0}^{1} x^2 dx & \frac{1}{2} \\ 2 & \int_{0}^{2} e^{-x} dx \end{bmatrix}

评估方式

哈希比较成功率: 模型生成的图片与参考图片哈希值完全相同的样本比例。
相似度比较成功率: 模型生成的图片与参考图片的图像相似度（直方图相似度/SSIM/MSE/特征点相似度 加权）高于阈值的样本比例。
最终综合得分: 上述两项成功率的加权平均值，全面反映模型的性能。

提示：测试数据的图像可能经过增强

点击展开详情

本次比赛可能会涉及一些基础图像增强变换，包括但不限于：

  1. 几何与空间变换
  • 旋转 (Rotation)
  • 透视变换 (Perspective)
  • 仿射变换 (Affine: 含缩放与错切)
  • 镜头畸变 (Lens Distortion)
  • 画布扩展与边缘裁剪 (Canvas Expansion & Border Trimming)
  1. 颜色与光照调整
  • 颜色抖动 (Color Jitter: 含亮度与对比度)
  • RGB 通道偏移 (RGB Shift)
  • 色温调整 (Color Temperature)
  • Gamma 校正 (Gamma Correction)
  • 通道随机丢失 (Channel Dropout)
  1. 噪声干扰
  • 高斯噪声 (Gaussian Noise)
  • 椒盐噪声 (Salt & Pepper Noise)
  • 泊松噪声 (Poisson Noise)
  • 散斑噪声 (Speckle Noise)
  1. 模糊与画质损伤
  • 高斯模糊 (Gaussian Blur)
  • 运动模糊 (Motion Blur)
  • JPEG 压缩伪影 (JPEG Artifacts)
 

评估数据包括两版，A榜 和 B榜，类似于验证集和测试集，样本均未公开。

资源

  • 代码：提供了两份 Lora SFT 的 baseline，基于 ms-swift 的 demo 和基于 XTuner 的 demo，均包括评估框架和微调代码。
    实测第一个 demo 在A榜得分 56.50，B榜得分 48.60.（其实这个分数一下就能进前 60 了。。）

  • 数据：提供有一个包含 3000 个图像文本对的训练数据集，上面两个 demo 都使用该数据集。

  • 奖金：1st, 2nd, 3rd, 4-20th, 21-60th 分别有 6/4/3/2/1k RMB. 是真的我作证，因为上一期拿到了 1k.

分析

InternVL3.5-1B 是 LLaVA 式的 VLM, 这类的 VLM 约等于 Vison Backbone + MLP + LLM，其中 MLP 相当于视觉和语言的桥梁，把视觉 token 映射到视觉语义共享的特征空间，作为 LLM 的视觉输入。
跑完 baseline 后，简单来说有以下改进方向：

  • 数据：①增加训练数据（寻找/合成）；②图像数据增强
  • 训练：③尝试不同的微调方式，如全量微调；调整微调不同部分的权重
  • 寻求更大的增益：④因为有明确的奖励信号，适合用 RL 优化模型偏好，把输出对齐到合法的 LaTex 文本；⑤通过后处理约束输出 LaTex 文本的合法性

过程

样本数量扩充
首先尝试了更大的开源数据集，直接扑街，A榜 1 分，B榜 0.2 分，统计命令出现频率发现数据分布天差地别，估计初始训练数据和 AB 榜相关性比较强。（后来举办方明确说明了初始训练数据和 AB 榜生成模式相同。好吧如果是我，我肯定给 B 榜数据构造点儿偏移）看了下初始数据，全是包含微分和矩阵的合成公式，本质上一个 LaTex 的高频子集，语法正确但不保证内容有意义。那么就根据初始数据的分布扩充数据。

第一版数据生成器比较粗糙，数据扩充到 9k 分数有提升。扩充到 20k 反而 A 榜分数有下降。这时由于评测时间过长，B 榜分数出现了严重的滞后，根据 A 榜表现放弃了 20k 版本的数据。
第二版数据生成器严格按照命令分布和长度生成数据，90k 数据效果依然拉跨，甚至不如 20k 版本。放弃。重心转移到下面几个方向。
这时还有两个可能没有探索：数据量上来后，是否该切到用全量微调；只约束了样本文本长度均值，没有约束分布。

数据清洗
观察文本命令分布时发现有很多不规则空格及换行符，感觉会干扰预测空间，与 AI 讨论后对文本做标准化，删除了所有换行符和多余空格。分数有提升。

数据增强
按照提示实现了类似 RandAug 的图像增强，调整某些增强的强度例如旋转角度在合理范围内。

多打几个补丁
Lora 仿佛在学习权重（而非特征）的残差，而且还能合并回原参数，像在预训练参数上打升级补丁。
那自然可以多打几个补丁强化任务适配，LLM，MLP, Vison, LLM+MLP 尝试了依次在这四个配置上微调，效果均有提升。
尝试了全量微调 LLM + MLP，A 榜效果等同 Lora 微调甚至略低，有点反直觉，可能是同时调整的参数太多。但这也符合（权重的）“残差”更易于学习的刻板印象。

小乌龙
提交允许自定义 prompt。什么？微调的 1B VLM 模型还有 prompt 工程价值？好吧确实可能有，我至少应该提示模型输出的公式语法要正确。于是设计了如下 prompt：

1
2
请根据图片中的公式生成对应的 latex 语法正确的公式文本。
*原 prompt：请根据图片中的公式生成对应的 latex 公式文本。

这是 native speaker 写出的中文句子？LLM 看了可能都不习惯，以后还是要多写作、多表达
结果，提交了八九次才发现第二版开始训练数据用的还是默认模板，搞笑。这个低级错误害我又提交了好几次重复权重来测 prompt 的影响，结论是好像没太大影响，B 榜波动小，A 榜波动大。

更进一步

一直瞎训提交 A 榜抽奖也没啥意思（主要是没啥进步空间了），不如趁这机会试试其他玩意

RL
对 RL 一直敬而远之，感觉需要大量时间和空间，事实证明确实如此。基于 trl 搭好 GRPO 框架，在 LLM 的辅助下设计了三个奖励函数，分别评估识别结果的语法正确性，和标签的编辑距离以及渲染结果和输入图片相似度（直接借用评测框架里的计算方式）。

小小的吐槽一下，怀疑比赛举办方没有 review 过 vibe coding 的评测框架代码，每种相似度评分都重复地进行预处理，以及实现了批量推理却没有使用，不知道是不是 B 榜出分缓慢的原因之一。

跑起来 GRPO 了，此时距比赛结束还有不到 48 小时，一看预计运行时间 40+ 小时，实际上更慢。中间还断了两次，感觉沐曦卡还不是特别稳定，国产算力任重道远。vllm 在沐曦上没找到合适环境，torch 版本太低，swift sample 也没调通，就龟速地一边推一遍训了。

log 里 clip_ratio=0、entropy 指标也在下降，Claude 说模型没学到啥，毕竟我看示例都是训了几百 ep，我这 1 ep 都跑不完，训了 600 steps，Lora 权重也没啥变化，有图为证，
image
RL 失败，按下不表。此时距比赛结束还有不到 30 小时.

约束解码/后处理
其实看到比赛题目时，有个疑问就浮在脑海：相似度评估真的有效吗
公式渲染方式一致，预处理方式一致，白/透明底黑字之间会有非常显著的差别吗？
对 10 张测试图像两两组合计算相似度均值，在默认加权中，相似度基本略高于 0.5-0.6，如果 B 榜评测时设置的相似度阈值较低，或者渲染成功就有分，那给 LLM 配个能正确渲染的保底输出，就能稳定提分。这里就要提到 transformers 的 AutoClass 类的 trust_remote_code 了，简单来说它允许加载模型仓库里的代码用于推理，给评估时的后处理提供了注入条件。实测默认返回一张初始训练集的样本 sample19996.png 结果是 A 榜 0 分，此路不通，推测相似度阈值应该在 0.7 甚至 0.75 以上。

按照约束解码的思路，根据完整的 LaTex 文法约束 token 采样，但 LaTex 语法略显复杂，先从错误样本做个简单版本：
推理 100 张测试图像有 6 个渲染错误，检查错误样本，归类错误原因。通过 logits processor 修复已知错误。于是请求 Claude，

在生成的公式中观察到的错误有：
1、没任何矩阵环境，生成了 &
2、生成不匹配的括号，例如 (]
3、编造的命令，例如：\vbeta
4、数字后出现下划线如 b_6_4
5、命令层级不匹配，如\begin{array} \begin{pmatrix} 后首先出现 \end{array}
6、…
请以类似约束解码的方式，举一反三地抑制不合法的输出，每种错误由一个函数来检查，使得易于检查和使用

Claude 创建了一个类 LatexState 记录生成过程的各种状态

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@dataclass
class LatexState:
    """追踪当前已生成序列的语法状态"""
    # 括号栈：追踪未闭合的括号
    bracket_stack: list = field(default_factory=list)
    # 环境栈：追踪 \begin{} \end{} 嵌套
    env_stack: list = field(default_factory=list)
    # 当前是否在矩阵环境中
    in_matrix_env: bool = False
    # 上一个有效 token 的文本
    last_token_text: str = ""
    # 已生成的完整文本
    generated_text: str = ""

    # 矩阵环境集合（允许使用 & 的环境）
    MATRIX_ENVS = {
        "matrix", "pmatrix", "bmatrix", "vmatrix", "Vmatrix",
        "smallmatrix", "array", "aligned", "align", "cases",
        "gather", "eqnarray",
    }
    # ...

基于 LatexState 的状态，定义了对应多种错误的检查函数，例如：

1
2
3
4
5
6
7
8
def check_ampersand_outside_matrix(candidate: str, state: LatexState) -> bool:
    """
    错误类型1：没有矩阵环境时生成 &
    返回 True 表示该 token 非法
    """
    if '&' in candidate and not state.in_matrix_env:
        return True
    return False
点击展开其他检查函数
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
def check_mismatched_brackets(candidate: str, state: LatexState) -> bool:
    """
    错误类型2：生成不匹配的括号，如 (]
    模拟将 candidate 加入当前括号栈，检查是否产生不匹配
    """
    PAIRS = {')': '(', ']': '[', '}': '{'}
    OPEN = set('([{')
    CLOSE = set(')]}')

    # 模拟当前栈
    simulated_stack = list(state.bracket_stack)
    for ch in candidate:
        if ch in OPEN:
            simulated_stack.append(ch)
        elif ch in CLOSE:
            if not simulated_stack:
                return True  # 无对应开括号
            if simulated_stack[-1] != PAIRS[ch]:
                return True  # 括号类型不匹配
            simulated_stack.pop()
    return False

def check_invalid_command(candidate: str, state: LatexState) -> bool:
    """
    错误类型3：编造的命令，如 \vbeta, \invalidcmd
    检测 candidate 中是否包含不在白名单的 LaTeX 命令
    """
    commands = re.findall(r'\\([a-zA-Z]+)', candidate)
    for cmd in commands:
        if cmd not in VALID_COMMANDS:
            return True
    return False


def check_consecutive_subscripts(candidate: str, state: LatexState) -> bool:
    """
    错误类型4：数字或字母后出现连续下划线，如 b_6_4
    检测合并后文本中是否有 x_y_z 的非法连续下标（未用{}包裹）
    """
    combined = state.generated_text + candidate
    # x_y_z 形式（未用 {} 包裹时的连续下标）
    if re.search(r'(?<!\{)[^_{}]+_[^_{}]+_', combined):
        return True
    return False


def check_env_order_mismatch(candidate: str, state: LatexState) -> bool:
    """
    错误类型5：\end{env} 与栈顶 \begin{env} 不匹配
    如 \begin{array}\begin{pmatrix} 后出现 \end{array}
    """
    ends = re.findall(r'\\end\{(\w+)\}', candidate)
    simulated_stack = list(state.env_stack)
    for env in ends:
        if not simulated_stack:
            return True  # 没有对应的 \begin
        if simulated_stack[-1] != env:
            return True  # 与栈顶不匹配
        simulated_stack.pop()
    return False


def check_illegal_characters(candidate: str, state: LatexState) -> bool:
    """
    错误类型6：非法 Unicode 字符（中文、全角等）
    """
    ILLEGAL_RANGES = [
        (0x4E00, 0x9FFF),   # 中文基本汉字
        (0x3400, 0x4DBF),   # 中文扩展A
        (0xFF00, 0xFFEF),   # 全角字符
        (0x3000, 0x303F),   # 中文标点
        (0x0080, 0x009F),   # C1控制字符
    ]
    for char in candidate:
        cp = ord(char)
        for start, end in ILLEGAL_RANGES:
            if start <= cp <= end:
                return True
    return False


def check_double_superscript(candidate: str, state: LatexState) -> bool:
    """
    错误类型7：连续上标，如 x^2^3（未用{}包裹）
    """
    combined = state.generated_text + candidate
    if re.search(r'\^[^{}\^]+\^', combined):
        return True
    return False


def check_empty_group(candidate: str, state: LatexState) -> bool:
    """
    错误类型8：空的花括号组 {}（通常无意义，在关键位置会导致渲染错误）
    """
    combined = state.generated_text + candidate
    # \frac{}{} 或 \sqrt{} 等关键命令后的空组
    if re.search(r'\\(frac|sqrt|hat|bar|vec|dot)\{\}', combined):
        return True
    return False
 

斯巴拉西，然后 Claude 给出了 logits processor 的实现

点击展开详情
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
class LatexConstraintProcessor(LogitsProcessor):
    def __init__(
        self,
        tokenizer,
        enabled_checkers: Optional[set] = None,  # None 表示启用全部
        penalty: float = -float('inf'),           # 非法 token 的惩罚值
        verbose: bool = False,
    ):
        self.tokenizer = tokenizer
        self.penalty = penalty
        self.verbose = verbose
        self.state = LatexState()

        # 选择启用的检查器
        if enabled_checkers is None:
            self.checkers = CHECKERS
        else:
            self.checkers = {k: v for k, v in CHECKERS.items() if k in enabled_checkers}

        # 预计算词表中每个 token 的解码文本（避免每步重复 decode）
        self._vocab_decoded = self._precompute_vocab(tokenizer)
        print(f"[LatexConstraintProcessor] 启用检查器: {list(self.checkers.keys())}")

    def _precompute_vocab(self, tokenizer) -> dict:
        vocab = tokenizer.get_vocab()
        decoded = {}
        for token, idx in vocab.items():
            try:
                decoded[idx] = tokenizer.convert_tokens_to_string([token])
            except Exception:
                decoded[idx] = ""
        return decoded

    def __call__(
        self,
        input_ids: torch.LongTensor,
        scores: torch.FloatTensor,
    ) -> torch.FloatTensor:

        # 更新状态：解码最新生成的 token
        if input_ids.shape[1] > 0:
            last_token_id = input_ids[0, -1].item()
            last_text = self._vocab_decoded.get(last_token_id, "")
            self.state.update(last_text)

        # 对每个候选 token 逐一检查
        banned_ids = []
        for token_id, candidate_text in self._vocab_decoded.items():
            for checker_name, checker_fn in self.checkers.items():
                if checker_fn(candidate_text, self.state):
                    banned_ids.append(token_id)
                    if self.verbose:
                        print(f"[banned] id={token_id} text={candidate_text!r} reason={checker_name}")
                    break  # 一个检查失败即禁止，无需继续

        if banned_ids:
            scores[0, banned_ids] = self.penalty

        return scores

    def reset(self):
        """每次新的生成前重置状态"""
        self.state = LatexState()
 

遍历整个词表可还行，试一下果然慢得要死。而且模型开始无休止地吐 token ，猜测是 EOS token 也被 mask 了，
把 special tokens 从 mask 名单去除，推理仍未正常结束。此时比赛已经结束了，提交了返回固定样本的版本。

再检查发现 EOS token 后出现的都是 pad token，应该是批量推理的其他样本尚未结束生成。进而发现上面版本的 batchsize 错误，input_ids[0, -1] 和 scores[0, banned_ids] 仅处理了批次中的第一个样本，继续提示 Claude，

整理上面的代码，给出 LatexState 和 LogitsProcessor 的完整版本。
1、根据 LatexState 记录的生成状态动态计算需要 mask 的 token，例如括号、命令，_ 等；
2、计算包含中文字符等非 LaTex 标准字符的 token 进行静态 mask；
3、适配批量处理的场景；

几轮提示和修改后，得到了一个勉强可用版本，不足之处在于把包含环境的复杂序列也在 token 级别处理，实际上应该从 token 流的角度考虑，但这样引入了太多复杂性，到此为止。

点击展开详情
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
class LatexConstraintProcessor(LogitsProcessor):

    def __init__(
        self,
        tokenizer=None,
        model=None,
        penalty: float = -float('inf'),
        verbose: bool = False,
    ):
        # 支持从 model.name_or_path 自动加载 tokenizer
        if tokenizer is None:
            assert model is not None, (
                "请传入 tokenizer 或 model：\n"
                "  LatexConstraintProcessor(tokenizer=tokenizer)\n"
                "  LatexConstraintProcessor(model=model)"
            )
            from transformers import AutoTokenizer
            tokenizer = AutoTokenizer.from_pretrained(
                model.name_or_path, trust_remote_code=True
            )

        self.tokenizer = tokenizer
        self.penalty = penalty
        self.verbose = verbose

        # EOS / 特殊 token
        self._eos_token_id = tokenizer.eos_token_id
        special_ids = set(tokenizer.all_special_ids)
        for attr in ('eos_token_id', 'bos_token_id', 'pad_token_id', 'unk_token_id'):
            val = getattr(tokenizer, attr, None)
            if val is not None:
                special_ids.add(val)
        self._special_token_ids = list(special_ids)

        # 预计算词表
        self._vocab_decoded, self._static_banned = self._precompute_vocab(tokenizer, special_ids)

        # 预计算动态检查索引
        self._precompute_token_indices()

        # batch 状态（延迟初始化）
        self.states: list[LatexState] = []

        print(
            f"[LatexConstraintProcessor] "
            f"特殊token: {len(special_ids)}个  "
            f"静态过滤: {len(self._static_banned)}个  "
            f"动态检查词表: {len(self._vocab_decoded)}个"
        )

    # ── 词表预计算 ──────────────────────────────────────────────

    def _is_legal_latex_char(self, text: str) -> bool:
        """判断文本是否只含合法 LaTeX 字符"""
        LEGAL_PATTERN = re.compile(
            r'^['
            r'a-zA-Z0-9'            # 英文字母和数字
            r'\s'                   # 空白字符（空格、换行、tab）
            r'\\{}()\[\]'           # LaTeX 核心符号
            r'\+\-\*/=<>!&|^~'      # 运算符
            r'_\^'                  # 上下标
            r'.,;:\'"`'             # 标点
            r'#%'                   # 其他常用  r'@#%'，按数据集改为 r'#%' 
            r']+$'
        )
        ILLEGAL_RANGES = [
            (0x4E00, 0x9FFF),       # 中文基本汉字
            (0x3400, 0x4DBF),       # 中文扩展A
            (0x20000, 0x2A6DF),     # 中文扩展B
            (0xFF00, 0xFFEF),       # 全角字符
            (0x3000, 0x303F),       # 中文标点
            (0x0080, 0x009F),       # 不可见控制符
            (0xD800, 0xDFFF),       # UTF-16 代理区
            (0xE000, 0xF8FF),       # 私有区
        ]
        for char in text:
            cp = ord(char)
            for start, end in ILLEGAL_RANGES:
                if start <= cp <= end:
                    return False
        return bool(LEGAL_PATTERN.match(text))

    def _precompute_vocab(
        self,
        tokenizer,
        special_ids: set,
    ) -> tuple[dict[int, str], torch.Tensor]:
        """
        返回：
          vocab_decoded: 合法 token 的 id → 文本（用于动态检查）
          static_banned: 非法字符 token 的 id tensor（静态屏蔽）
        """
        vocab = tokenizer.get_vocab()
        static_banned = []
        vocab_decoded = {}

        for token, idx in vocab.items():
            # 特殊 token 直接保留，内容置空（不参与任何规则检查）
            if idx in special_ids:
                vocab_decoded[idx] = ""
                continue
            try:
                text = tokenizer.convert_tokens_to_string([token])
            except Exception:
                vocab_decoded[idx] = ""
                continue

            if not self._is_legal_latex_char(text):
                static_banned.append(idx)
            else:
                vocab_decoded[idx] = text

        return vocab_decoded, torch.tensor(static_banned, dtype=torch.long)

    def _precompute_token_indices(self):
        """
        按字符内容预分组，供动态屏蔽 O(1) 查找：
          _tokens_contain[ch] → 以字符 ch 开头的所有 token id 列表
          _end_env_ids[env]   → 包含 \\end{env} 的 token id 列表
          _cmd_token_ids      → 包含未知命令的 token id 列表（静态）
        """
        # 关键字符分组
        KEY_CHARS = ('^', '_', '&', ']', ')', '}')
        self._tokens_startwith: dict[str, list[int]] = {ch: [] for ch in KEY_CHARS}

        # \end{env} 分组
        self._end_env_ids: dict[str, list[int]] = {}

        # 非法命令（静态，加入 static_banned）
        invalid_cmd_ids = []

        for token_id, text in self._vocab_decoded.items():
            if not text:
                continue

            # 按包含字符分组
            for ch in KEY_CHARS:
                if text.lstrip().startswith(ch):
                    self._tokens_startwith[ch].append(token_id)

            # \end{env} 分组
            m = re.search(r'\\end\{(\w+)\}', text)
            if m:
                env = m.group(1)
                self._end_env_ids.setdefault(env, []).append(token_id)

            # 非法命令检查
            commands = re.findall(r'\\([a-zA-Z]+)', text)
            if any(cmd not in VALID_COMMANDS for cmd in commands):
                invalid_cmd_ids.append(token_id)

        # 非法命令并入静态禁止
        if invalid_cmd_ids:
            extra = torch.tensor(invalid_cmd_ids, dtype=torch.long)
            self._static_banned = torch.cat([self._static_banned, extra]).unique()

    # ── 动态屏蔽 ────────────────────────────────────────────────

    def _get_context_banned(self, state: LatexState) -> list[int]:
        """根据当前状态返回需要动态屏蔽的 token id"""
        banned = []

        # 规则1：^ 或 _ 之后尚未完整参数，禁止再出现 ^ 和 _
        if not state.script_has_arg:
            banned.extend(self._tokens_startwith['^'])
            banned.extend(self._tokens_startwith['_'])

        # 规则2：刚完成一个脚本参数（如 a^1 或 a^{12} 末尾），
        # 则禁止紧接着生成同类脚本（防止 a^1^ 或 a_1_2）
        # 注意：不禁止另一类，a^1_2 是合法的
        elif state.script_just_completed and state.last_script_char:
            banned.extend(self._tokens_startwith[state.last_script_char])

        # 规则3：不在矩阵环境，禁止 &
        if not state.in_matrix_env:
            banned.extend(self._tokens_startwith['&'])

        # 规则4：括号栈顶不匹配，禁止对应非法闭合括号
        if state.bracket_stack:
            top = state.bracket_stack[-1]
            for illegal_close in BRACKET_MISMATCH.get(top, ()):
                banned.extend(self._tokens_startwith[illegal_close])
        else:
            # 禁止所有闭合括号
            for illegal_close in CLOSE_BRACKETS:
                banned.extend(self._tokens_startwith[illegal_close])

        # 规则5：\end{env} 必须与栈顶匹配
        if state.env_stack:
            top_env = state.env_stack[-1]
            for env, ids in self._end_env_ids.items():
                if env != top_env:
                    banned.extend(ids)

        return banned

    # ── __call__ ────────────────────────────────────────────────

    def __call__(
        self,
        input_ids: torch.LongTensor,   # [batch, seq_len]
        scores: torch.FloatTensor,     # [batch, vocab_size]
    ) -> torch.FloatTensor:

        batch_size = input_ids.shape[0]
        device = scores.device

        # 延迟初始化 / batch size 变化时重置状态
        if len(self.states) != batch_size:
            self.states = [LatexState() for _ in range(batch_size)]

        # 设备对齐（只在首次或设备变化时迁移）
        if self._static_banned.device != device:
            self._static_banned = self._static_banned.to(device)

        for i in range(batch_size):
            # 已生成 EOS 的样本跳过
            if self._eos_token_id is not None:
                if (input_ids[i] == self._eos_token_id).any():
                    continue

            # 更新第 i 个样本的状态
            if input_ids.shape[1] > 0:
                last_id = input_ids[i, -1].item()
                last_text = self._vocab_decoded.get(last_id, "")
                self.states[i].update(last_text)

                if self.verbose:
                    print(
                        f"[batch={i}] last_token={last_text!r}  "
                        f"env_stack={self.states[i].env_stack}  "
                        f"bracket_stack={self.states[i].bracket_stack}  "
                        f"in_matrix={self.states[i].in_matrix_env}"
                    )

            # 静态屏蔽
            scores[i, self._static_banned] = self.penalty

            # 动态屏蔽
            context_banned = self._get_context_banned(self.states[i])
            if context_banned:
                scores[i, context_banned] = self.penalty

        # 强制恢复所有特殊 token（确保 EOS 不被屏蔽）
        for sp_id in self._special_token_ids:
            scores[:, sp_id] = scores[:, sp_id].clamp(min=0)

        return scores

    def reset(self):
        """每次新的 generate 调用前重置所有状态"""
        self.states = []
 

效果
实现的简易约束解码效果挺抽象，公式生成变得合法了，但正确性下降了。
随机 100 个合成公式的测试结果：评分大幅下降，渲染失败个数从 3 个减少到 1 个，换了个子集甚至得到更多的渲染失败。
问题可能在于单个 token 级别的约束实际破坏了模型的 LaTex 表示能力，表示能力是建立在语法单元上的，
而它们由多个 token 组成（或者相反一个 token 超过了一个基本单元），因此单个 token 的约束和语法单元并不对齐

image

插曲

跑评测时发现某些情况会报错，图片成功渲染了相似度却通通是 0，细察发现图片读取部分有问题，
用 dvipng 把 latex 编译结果转换为 png 格式时，可能会把 RGBA 优化成 colormap，导致 cv2.imread 读取有误，应该也影响 hash 。。
复现 bug 提了 issue 和 PR，在微信群里看到好像有 B 榜分数有震荡，不知道是不是这个原因
同一张图片，因读取问题产生的相似度分数差异：

image image

经验、教训与感受

想了下，比赛过程有些缺乏章法，接近炼丹了。

  • 应该尽早构造验证集和本地评测流程，检查错误样本。
    这样就能更早地推进约束解码/后处理的方案，以及通过本地评估指导数据合成。
  • 科学炼丹：应该排实验计划，对每个有希望的方向进行试训。
    比如对全量微调探索太少，可以尝试分阶段微调和清洗后的合成数据集微调。
  • 应该尽早投入比赛。。好吧其实没邀请对象没有那么多算力。
  • 拥抱 AI 力度不够（还是舍不得买 Claude，以及完全放手给 Coding Agent）
    上一期最后没抢到算力，准备的最后一版数据没用上，直接被挤出前 20 了。最后观摩一个公开出来的前三的方案，AI 代码 AI 报告看得我两眼一黑。毫无疑问这次我又将与 Claude Opus 作战，本着打不过就加入的原则在 review 和验证中大量使用 AI 代码，但效率有限。这次我将把奖金上交智谱。（好吧有 Codex 已经满足了）
  • 比第一次有进步
    第一次完全没理解模型仓库 GitHub 格式和 HF 格式的差异，这次终于有所了解，对 LLM/VLM 处理输入到输出的过程也更清晰了。尝试 ms-swift 框架的同时第一次跑起来 RL 代码（虽然是用 trl），强化学习并非高高在上，遥不可及！
  • 把 LLM 的知识蒸馏给自己
    接受 AI，拥抱 AI，努力达到 AI 的边界，但不把 AI 的能力误认为自己的能力。
    可是我们做到一件事，必须要掌握全部细节吗，我此刻产生了怀疑。领导者的能力一定要覆盖或超过下属吗？知其然知其所以然，可学也无涯。只能寄希望于“本体越强，替身使者越强”，否则只需要强化人机同步率了，健身还有什么用呢？也许我还停留在“学习技术”提供的多巴胺舒适区吧。
  • 对于可靠系统 vibe coding requires review.

仓库

除了最初版的数据生成器丢失了，本次比赛产生的各种未经整理的代码放在了 kafmws/VLM-formula-recognition-dataset.git

未尽探索

增加视觉 token 数量、增大图像输入分辨率，也是显而易见的方向。但担心会破坏预训练模型的视觉特征提取能力，没尝试这些脑海里一闪而过的念头，还是有些可惜。RL 和约束解码也尝试太晚，没有成功应用到提交中。
下次再来！

2026/03/02

]]> <h1 id="参赛记录"><a class="markdownIt-Anchor" href="#参赛记录"></a> 参赛记录</h1> <p>本文记录参加书生大模型社区比赛的一些过程。</p> <h2 id="比赛简介"><a class="markdownIt-Ancho LLM 结构化输出原理、实现方式及实践 https://www.kafm.eu.org/note/LLM/LLM%20%E7%BB%93%E6%9E%84%E5%8C%96%E8%BE%93%E5%87%BA%E5%8E%9F%E7%90%86%E3%80%81%E5%AE%9E%E7%8E%B0%E6%96%B9%E5%BC%8F%E5%8F%8A%E5%AE%9E%E8%B7%B5/ 2026-02-03T02:43:54.000Z 2026-03-05T08:20:24.000Z 结构化输出的意义

LLM 是输出不可控的概率模型，而结构化输出则增强输出的可控性。
有了这种可控性，LLM 就具备了一个程序的交互 interface 可以稳定地接入上下游程序，比如调用工具

结构化输出的原理及实现方式

实现格式化输出通常有以下几种手段，

  • 提示词工程
    通过指令 “只输出JSON”，few-shot 示例等提示词技巧引导模型进行格式化输出
  • 后处理
    instruct 等库对模型输出进行后处理，进行提取或修复等。包括解析后反馈错误重新生成等。
  • 约束解码
    在选择 token 时用 mask 机制直接排除不符合输出格式的候选 token，在有限输出空间内选择 token。
    {"key": value}，从仅让模型预测格式串中的value部分，到约束value的格式/类型，约束解码都可以保证可靠的格式化输出。
    再进一步，通过等价的状态机进行约束解码，可以进行任意的格式化输出。约束解码是结构化输出的主要工程手段。
  • SFT / RL
    通过后训练手段形成输出偏好，使模型遵循一定模式。可靠性高，是结构化输出的理论保障、能力来源。

当前许多模型厂商从 SFT/RL 的角度增强模型的格式化输出能力，并从推理端实现约束解码（例如Ollama），从而提供可靠的结构化输出 API。

工具调用与结构化输出，先有鸡还是先有蛋

依靠结构化输出的结果，我们才能稳定地处理工具调用
然而，如果模型能调用给定的工具，那么任意输出格式都可以包装成工具，通过 LLM 填写调用参数，也就实现了指定格式的输出
看起来两者相互成就，已经变成了鸡生蛋，蛋生鸡的问题
许多厂商都强调模型有tool use/ function call能力，却不强调模型支持结构化输出，可能工具使用能力是结构化输出的内核吧，结构化输出结合了众多工程手段来提供可靠性

本地模型在 langchain 中的结构化输出

本文在 langchain 以下生态中进行讨论（2026-02-02）

1
2
3
langchain-core            1.2.7
langchain-openai          1.1.7
langchain-ollama          1.0.1

以 YesNoJudge 类的 JSON 格式，搭配不同 with_structured_output() 的格式化输出方式（即method参数）测试结构化输出表现
method 参数可选项有 json_schema, function_calling 和 json_mode，其中json_mode因无法给出确定格式的 JSON ，需要后处理，不推荐使用。（来源：https://platform.openai.com/docs/guides/structured-outputs#json-mode）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class YesNoJudge(BaseModel):
    """return judge result from the context with this function."""

    yes_or_no: Literal["yes", "no"] = Field(
        description="The answer should be either 'yes' or 'no'"
    )
    explanation: str


judge = ChatOpenAI(
            model=model_name, temperature=0.6, streaming=True, **fast_judge_config
        )
        judge = judge.with_structured_output(
            schema=YesNoJudge, method="function_calling", strict=True, include_raw=True
        )
image图：指定`json_schema` 方式，在 prompt 中提示按JSON格式输出后，gpt-oss:20b 仍调用不存在的工具进行格式化输出image图：指定 `function_calling` 方式，在 prompt 中提示按JSON格式输出后，qwen3:4b 会在内容中输出 json，不调用工具image图：指定 `function_calling` 方式，去除json prompt，qwen3:4b 仍倾向于遵循指令在内容中输出结果，不调用工具image图：指定 `function_calling` 方式，去除指令式prompt，qwen3:4b 有概率调用工具返回结果

可见 Qwen 模型更重视指令遵循，而 GPT 偏向于使用工具

langchain 中 with_structured_output() 的实现简析

不同 backend 生态包的 with_structured_output() 实现不同，
对于langchan-openai：

  • function_calling 把 JSON schema 作为 tool 传入，并填充 tool_choice 参数，强制 LLM 使用工具输出工具调用的 schema
    相当于把工具调用能力转化为结构化输出能力
  • json_schema 方式则是对输出内容进行解析，该参数
  • json_mode 建议配合 prompt 使用，全靠模型发挥
    而 create_agnet API 中 response_format 也是直接调用 LLM 后端的结构化输出能力

langchain + langchain-openai + Ollama 后端结构化输出踩的坑

为什么用 langchain-openai 不用 langchain-ollama，因为想着兼容 OpenAI API 会好一些
甚至用 langchain-ollama + Ollama 还一直出现 502 报错。。openai / curl 均正常

  • 看似兼容，实则不兼容
    如 langchain[openai, ollama] 中 chat_models 的 with_structured_output() 实现不一致
    且将 Ollama 作为后端使用 langchain-openai 时 with_structured_output 的表现和模型高度相关，需根据模型调优 method 参数
    实际支持多个后端仍需要进行适配

  • 多处实现，效果不一
    如langchain[openai, ollama]中chat_models的with_structured_output()与from langchain.agents import create_agent的response_format都用于结构化输出，然而可靠性不同

  • 过度封装
    源码里到处是消除警告的类型不匹配 # type: ignore
    MessageState 的消息 messages 传入 AgentState 的 messages 提示类型不匹配，有点搞笑

]]> <h2 id="结构化输出的意义"><a class="markdownIt-Anchor" href="#结构化输出的意义"></a> 结构化输出的意义</h2> <p>LLM 是输出不可控的概率模型，而结构化输出则增强输出的可控性。<br /> 有了这种可控性，LLM 就具备 龙潭公园里的鹅和鸭们日子过得无忧无虑 https://www.kafm.eu.org/fragment/Fragments/%E9%BE%99%E6%BD%AD%E5%85%AC%E5%9B%AD%E9%87%8C%EF%BC%8C%E9%B9%85%E5%92%8C%E9%B8%AD%E4%BB%AC%E6%97%A5%E5%AD%90%E8%BF%87%E5%BE%97%E6%97%A0%E5%BF%A7%E6%97%A0%E8%99%91/ 2025-12-21T12:43:54.000Z 2026-03-05T08:20:24.000Z 龙潭公园里的鹅和鸭们日子过得无忧无虑呐。

潭水表面大都结着冰，沿潭水绕行一圈，每个鹅鸭聚集的岸边都有人在喂食，有馒头，有不知名的食儿，甚至还有个眼镜哥带一大串葡萄来喂。
馒头屑浮在水面上，鸭子悠悠游来伸脖一衔便进肚，而葡萄都沉入水中。
有鸭子站在冰面上了，就有葡萄滚落周围，这下总能吃了吧！
可葡萄圆滚滚的，这黑绿头的鸭子用窄窄扁扁的嘴衔几次掉落几次，只有极少数葡萄完成了使命。
眼镜哥毫不在乎，在冰上、在水里，吃不吃、吃不吃得着无关紧要，喂食本是一种过程。

继续往前走，又一大群鸭，和拎一大袋馒头的大姨。这边鸭也是游水时偷闲吃两口，但成群结队游向岸边还是给足了大姨面子。
有旁人说道，一清早就有人喂过了！
怨不得鸭吃得糊弄，原来是尝个咸淡，看合不合胃口。

龙潭公园里，鹅和鸭们日子过得无忧无虑呐。

25年12月21日

]]> <p>龙潭公园里的鹅和鸭们日子过得无忧无虑呐。</p> <p>潭水表面大都结着冰，沿潭水绕行一圈，每个鹅鸭聚集的岸边都有人在喂食，有馒头，有不知名的食儿，甚至还有个眼镜哥带一大串葡萄来喂。<br /> 馒头屑浮在水面上，鸭子悠悠游来伸脖一衔便进肚，而葡萄都沉入水中。<br /> 书生大模型论文分类微调赛参赛记录 https://www.kafm.eu.org/record/LLM/%E4%B9%A6%E7%94%9F%E5%A4%A7%E6%A8%A1%E5%9E%8B%E8%AE%BA%E6%96%87%E5%88%86%E7%B1%BB%E5%BE%AE%E8%B0%83%E8%B5%9B%E5%8F%82%E8%B5%9B%E8%AE%B0%E5%BD%95/ 2025-08-06T06:43:54.000Z 2026-04-06T06:33:50.000Z 写在前面

https://aicarrier.feishu.cn/wiki/Gr7Iw6vhTiniMUkBIPvcfBiAnkg

有点遗憾，后面没抢到 GPU，感觉找到正确堆数据的方法了，没 scale 起来，最终从 10 名左右滑落到 28 名

看了排名靠前的一个佬的报告和代码，AI 成分非常重，代码和报告都是 AI 写的

我们古法编程爱好者还是输给了AI 🤡

不，我还没输，我只是没抢到卡没 scale 起来

基于以下信条，参加比赛：

Random is a strong baseline.

DL is data-driven ML.

微调策略

草草调研了下微调方法，还是回到了 Lora，LLM 量化了应该算应该算 QLora 吧

调整了 batchsize 和 梯度累积，学习率和 Lora 参数没动，Lora 的 rank 和 alpha 参数可以尝试下倍数关系

但我觉得对这个比赛来说，数据才是制胜法宝

直接 SFT，不进行 Pretrain，（虽然教程教大家 Pretrain …

数据处理

  • 有个类别的名字 math.PH 需要修正，或者把 math-ph 映射回去

丰富模板

  • 用 DeepSeek 和 ChatGPT 各生成了一些模板，最后用了 136 个对话模板，22 个系统指令
  • 尝试改变选项和题干的先后顺序、对选项增加中文名称，反而掉点，老老实实用回原本格式的模板了
  • 如果我设置 test split，肯定整很多花样的模板，比如变换选项顺序
    （可能需要考虑能不能收敛，对 Lora 来说应该还好）

Scaling up

  • Kaggle 上的数据集挺新的，和 arxiv 上没差多少，爬 arxiv 的收益感觉可以忽略不计，像尾部类别 cs.OS 好像也就多了近两三个月的 几十条 数据
  • 找到正确方向（一定量的简单模板 + 正确的论文抽取和样本生成后）逐渐尝试了每类别 1k，2k，3k，6k 的数据量
  • 尾部类别也没多采样，小模型怕过拟合，而且不到 10 倍也不算严重长尾；何况所有尾类数据都包括进去了，已经拿着答案在背了

数据过滤

  • 单类别 => 主类别 => 过滤交叉类别样本
  • 一开始为了数据质量，限制只选择单类别样本，数量太少；后来扩大到 主类别 为目标类别的样本
  • 后来检查数据，发现有些类别重叠很严重，像 cs.MM，本来就是 CV/AI 之类的交叉严重的研究领域，而且这个类别样本数量有限；尝试了去掉交叉类别样本，训练感觉没有明显差异
  • 最后看到 赛题文档有更新。。。
    image

放心地把交叉类别样本都过滤了

不足之处

  • 没考虑也没尝试全量训练，（full 在这个任务上一定能优于 Lora 吗，存疑）
  • 调整 Lora 参数范围，例如增加 o_proj 之类的
  • 没牢牢占住算力，导致没 scale 起来

数据处理代码

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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
import os
import json
import random

random.seed(42)

output_base_dir = 'internlm/dataset'
if not os.path.exists(output_base_dir):
    os.makedirs(output_base_dir)

input_templates = [
    "Based on the title '{title}', authors '{authors}', and abstract '{abstract}', please determine the scientific category of this paper.",

    "Classification Request: Given the title '{title}', authored by '{authors}', and abstract '{abstract}', identify the research field of this paper.",

    "Field Determination: Analyze the title '{title}', authors '{authors}', and abstract '{abstract}' to assign a discipline category.",

    "Academic Categorization: Based on '{title}' (authors: '{authors}') and abstract content '{abstract}', classify this paper into a scientific domain.",

    "Domain Assignment: Using the title '{title}', author list {authors}, and abstract text '{abstract}', determine the most relevant academic field.",

    "Research Area Identification: From the paper titled '{title}' (by {authors}) and abstract '{abstract}', infer its primary research area.",

    "Paper Taxonomy: Categorize the paper with title '{title}', authors {authors}, and abstract '{abstract}' into a specific scientific discipline.",

    "Subject Labeling: With the metadata: Title '{title}', Authors {authors}, Abstract '{abstract}', generate a subject classification.",

    "Knowledge Domain Inference: Based on '{title}' (by {authors}) and abstract '{abstract}', predict the broad field of study.",

    "Scientific Field Prediction: Analyze the title '{title}', authors {authors}, and abstract '{abstract}' to output a single discipline label.",

    "Multi-Metadata Classification: Integrate the paper\'s title '{title}', author affiliations '{authors}', and abstract '{abstract}' to assign a research category.",
    
    "分类请求：根据标题“{title}”、作者“{authors}”和摘要“{abstract}”，请确定该论文的研究领域。",

    "领域判定：结合标题“{title}”、作者{authors}及摘要内容“{abstract}”，判断此论文所属学科类别。",

    "学术分类：基于论文标题“{title}”（作者：{authors}）和摘要“{abstract}”，将其划分到具体的科学领域。",

    "学科标注：根据标题“{title}”、作者列表{authors}和摘要文本“{abstract}”，确定最相关的学术领域。",

    "研究方向识别：从标题为“{title}”（作者{authors}）及摘要“{abstract}”中推断其主要研究方向。",

    "文献归类：将标题“{title}”、作者{authors}、摘要“{abstract}”的论文归类至特定学科门类。",

    "主题分类：根据元数据：标题“{title}”、作者{authors}、摘要“{abstract}”，生成一个学科分类标签。",

    "知识领域推断：基于标题“{title}”（作者{authors}）及摘要“{abstract}”，预测其所属广泛研究领域。",

    "科学领域预测：分析标题“{title}”、作者{authors}和摘要“{abstract}”，输出单一学科标签。",

    "多维度分类：综合论文标题“{title}”、作者信息{authors}和摘要“{abstract}”，划分研究类别。",

    "Label the research domain of this paper by analyzing:\nTitle: {title}\nAuthors: {authors}\nKey findings: {abstract}'",
    
    "Q: Which academic field does the paper '{title}' by {authors} belong to, given its abstract: '{abstract}'?\nA: The field is:",
    
    "This paper [{title}] authored by {authors} primarily focuses on ______ (fill in the field), as evidenced by the abstract: '{abstract}'.",
    
    "Reviewer Task: Based on the title '{title}', author affiliations {authors}, and abstract summary '{abstract}', assign a discipline category from the taxonomy codes.",
    
    "If the paper '{title}' by {authors} were a book in a library, which section would it shelve in? Abstract clues: '{abstract}'.",

    "Step 1: Extract keywords from '{title}' and abstract: '{abstract}'.\nStep 2: Cross-reference with author '{authors}' expertise.\nStep 3: Output the dominant field.",

    "Compare these metadata to classify the paper:\nTitle focus: {title}\nAuthor expertise: {authors}\nAbstract emphasis: {abstract}\nConclusion: The paper belongs to _____ field.",

    "Can you accurately categorize {title} by {authors} just from this abstract? Prove it: '{abstract}'.",

    "Inputs:\nMetadata: Title={title}, Authors={authors}\nContent: Abstract={abstract}\nProcessing: Apply field codes.\nOutput: Field=?",

    "The DNA of this paper ({title} by {authors}) reveals its academic species. Abstract strand: '{abstract}'. Species identification:",

    "Research Area Identification: From the paper titled '{title}' (by {authors}) and abstract '{abstract}', infer its primary research area.",

    "Paper Taxonomy: Categorize the paper with title '{title}', authors {authors}, and abstract '{abstract}' into a specific scientific discipline.",

    "Subject Labeling: With the metadata: Title '{title}', Authors {authors}, Abstract '{abstract}', generate a subject classification.",

    "Knowledge Domain Inference: Based on '{title}' (by {authors}) and abstract '{abstract}', predict the broad field of study.",

    "Discipline Prediction: Analyze the abstract '{abstract}' of the paper '{title}' authored by {authors} and suggest the academic domain.",

    "Field Classification Task: Use the title '{title}', authors {authors}, and abstract '{abstract}' to assign a research category.",

    "Scientific Area Determination: Given the information — Title: '{title}', Authors: {authors}, Abstract: '{abstract}' — identify the scientific domain.",

    "Area Tagging: From the context of the paper '{title}' and its abstract '{abstract}', assign a field label.",

    "Disciplinary Mapping: With the title '{title}', the author(s) {authors}, and the abstract '{abstract}', map this paper to a discipline.",

    "Research Field Suggestion: Based on the content in the title '{title}' and abstract '{abstract}', recommend the research field.",

    "Topic Classification: Classify the following paper by title '{title}', authors {authors}, and abstract '{abstract}'.",

    "Academic Field Categorization: Given the title '{title}' and abstract '{abstract}', determine which academic field this paper falls into.",

    "Scientific Discipline Inference: Determine the scientific discipline of the paper titled '{title}' (authors: {authors}) based on the abstract '{abstract}'.",

    "Field Assignment Task: Use the provided paper metadata to assign the appropriate research area. Title: '{title}', Authors: {authors}, Abstract: '{abstract}'.",

    "Content-Based Field Classification: Determine the field of study using the paper's title '{title}', authors {authors}, and abstract '{abstract}'.",

    "Scholarly Classification Prompt: Use the paper title '{title}', author list {authors}, and abstract '{abstract}' to classify the research area.",

    "Discipline Deduction: From the title '{title}', author list {authors},  and abstract '{abstract}', deduce the primary academic discipline.",

    "Study Area Determination: Determine the core area of study of the paper titled '{title}' authored by {authors} from the abstract '{abstract}'.",

    "Category Prediction Task: Predict the research category using the paper title '{title}' and abstract '{abstract}'.",

    "Field Analysis Instruction: Based on metadata (title: '{title}', authors: {authors}, abstract: '{abstract}'), identify the study field.",

    "**分类请求：**根据标题“{title}”、作者“{authors}”和摘要“{abstract}”，请确定该论文的研究领域。",

    "**领域判定：**结合标题“{title}”、作者{authors}及摘要内容“{abstract}”，判断此论文所属学科类别。",

    "**学术分类：**基于论文标题“{title}”（作者：{authors}）和摘要“{abstract}”，将其划分到具体的科学领域。",

    "**主题标签生成：**请依据论文的标题“{title}”、作者“{authors}”及摘要“{abstract}”，为其生成对应的学科标签。",

    "**领域识别任务：**请根据以下论文信息（标题：“{title}”，作者：{authors}，摘要：“{abstract}”）识别其研究领域。",

    "**学科归类请求：**请将题为“{title}”、作者为{authors}的论文，基于摘要“{abstract}”进行学科归类。",

    "**研究领域预测：**请根据论文摘要“{abstract}”内容，预测标题为“{title}”的论文的研究领域。",

    "**论文领域自动识别：**输入信息包括标题“{title}”、作者{authors}、摘要“{abstract}”，请自动判断其学科领域。",

    "**学术方向分类任务：**请根据以下论文元数据，判断其研究方向。标题：{title}，作者：{authors}，摘要：{abstract}。",

    "**科学领域分类：**根据论文题目“{title}”和作者“{authors}”、摘要“{abstract}”，将其归类到相应的科学领域。",

    "**领域推理任务：**利用标题“{title}”、作者“{authors}”及摘要“{abstract}”对论文进行研究方向推理。",

    "**领域划分：**请根据“{title}”和“{abstract}”信息，作者为“{authors}”，判断其归属的学术领域。",

    "**分类辅助：**请依据标题“{title}”和作者{authors}的摘要“{abstract}”内容，推荐一个合适的研究分类。",

    "**领域归属分析：**根据论文内容判断其属于哪个研究领域。信息如下：标题：{title}；作者：{authors}；摘要：{abstract}。",

    "**学科方向识别：**请根据摘要“{abstract}”和标题“{title}”，作者是“{authors}”，识别该论文的学科方向。",

    "**论文归类任务：**依据论文元数据“{title}”、“{authors}”、“{abstract}”，请将其归类为某一学科类别。",

    "hich academic field does this paper belong to? Based on its title '{title}', authors {authors}, and abstract '{abstract}', determine the most suitable classification.",

    "Assign a scientific category to the paper below, using its metadata: Title: '{title}', Authors: {authors}, Abstract: '{abstract}'.",

    "Summarize the domain of study that best fits the research described in '{title}' by {authors}. Consider the abstract: '{abstract}'.",

    "Field estimation challenge: Based on the content of this scholarly work (Title: '{title}', by {authors}. Abstract: '{abstract}'), which field is it most aligned with?",

    "Discipline tagging assistant: Help identify the most relevant field for the paper titled '{title}' by {authors}, summarized as: '{abstract}'.",

    "Knowledge scope detection: Use the following metadata to detect the academic scope: Title - '{title}'; Authors - {authors}; Abstract - '{abstract}'.",

    "Contextual paper classification: Examine the title and abstract provided, and place the research in an appropriate scientific taxonomy.",

    "Suggest a domain label for the paper titled '{title}' with abstract '{abstract}'. Focus on broad scientific or technical fields.",

    "Research domain detection: This paper (title: '{title}'; abstract: '{abstract}') was written by {authors}. What is its academic category?",

    "Infer the scholarly classification from the semantic cues in the abstract '{abstract}', title '{title}', and authorship {authors}.",

    "**请问这篇论文属于哪个研究领域？**以下是其基本信息：标题“{title}”，作者{authors}，摘要“{abstract}”。",
    
    "**基于内容的领域分类：**请分析论文标题“{title}”和摘要“{abstract}”，判断其所属的科学门类。",
    
    "请对以下论文信息进行分类，包括标题“{title}”、作者{authors}和摘要“{abstract}”。",
    
    "**根据语义内容判断类别：**请从摘要“{abstract}”和标题“{title}”中提取关键信息，为论文分配一个学术领域。",
    
    "**帮我标注该论文的研究方向：**信息如下：{title}，作者：{authors}，摘要内容：“{abstract}”。",
    
    "**该研究更偏向哪个学科？**结合论文标题与摘要信息，请给出一个合理的分类建议。",
    
    "**从专业角度判断：**基于论文“{title}”与其研究摘要“{abstract}”，其应属于哪个专业领域？",
    
    "**请推荐一个学术标签，**用于表示这篇由{authors}撰写、标题为“{title}”的论文所属领域。",
    
    "**摘要分析分类：**请从该摘要“{abstract}”推测研究方向，并结合论文标题“{title}”做出归属判断。",

    "**内容归类任务提示：**请使用该论文的元数据（{title}、{authors}、{abstract}）对其进行领域标签的生成。",

    "Classify this paper into a research field. Title: '{title}', Authors: ({authors}), Abstract: '{abstract}'.",

    "Given: title '{title}', authors '{authors}', abstract '{abstract}'. Determine the academic domain.",

    "Use the abstract to assign a research category. Title: '{title}', Authors: '{authors}',  Abstract: '{abstract}'.",

    "Input: '{title}' by '{authors}'. Abstract: '{abstract}'. Output: scientific field.",

    "From the title and abstract, categorize this paper. Title: '{title}'. Abstract: '{abstract}', Authors: ({authors}).",

    "Can you help me figure out what field this paper belongs to? Here's the info: title '{title}', authors {authors}, abstract '{abstract}'.",

    "I\'m trying to organize some papers. What category should this one go into? Title: '{title}', Authors: {authors}, Abstract: '{abstract}'.",

    "I read this paper, but I'm unsure about its domain. Can you classify it? Title: '{title}', Abstract: '{abstract}', Authors: '{authors}'.",

    "Which research area would you assign to this work based on its abstract and title? Title: '{title}', Authors: '{authors}',  Abstract: '{abstract}'.",

    "You are an academic journal editor. Based on the title '{title}', authors {authors}, and abstract '{abstract}', assign this paper to a suitable discipline.",

    "As a librarian building a research taxonomy, determine the subject area for the paper: '{title}' by {authors} and abstract: '{abstract}'.",

    "Act as a scientific reviewer. Categorize this manuscript by domain using: Title: '{title}', Abstract: '{abstract}', Author List: '{authors}'.",

    "From the abstract '{abstract}' and title '{title}', (authors {authors}), what can you infer about the research domain of the paper?",

    "What clues in the abstract '{abstract}' and title '{title}', (authors {authors}) suggest the field of study?",

    "Analyze the keywords and topics in '{abstract}' and classify accordingly. And title '{title}', (authors {authors}).",

    "[System] Input received. Paper Title: '{title}', Authors: {authors}, Abstract: '{abstract}'. Proceed to classify by domain.",

    "[AI_Tagger] Please assign subject label based on: Title = '{title}', Abstract = '{abstract}', Author List: '{authors}'.",

    "[MetadataAnalyzer] Classify this entry using embedded text: '{abstract}' (title: '{title}'), (authors {authors}).",

    "Title = '{title}', Abstract = '{abstract}', Author List: '{authors}'. This paper was submitted for classification. Use the metadata to determine the category.",

    "Title = '{title}', Abstract = '{abstract}', Author List: '{authors}'. Generate a domain label based on the core ideas from the abstract and title provided.",

    "请根据标题“{title}”、作者{authors}和摘要“{abstract}”，对该论文进行学科分类。",

    "任务：对以下论文分类。标题：{title}；摘要：{abstract}； 作者列表“{authors}”。",

    "输入元信息：标题“{title}”，摘要“{abstract}”，作者列表“{authors}”。输出：研究领域。",

    "Title = '{title}' Author List: '{authors}', Abstract = '{abstract}',. 分类需求：根据论文摘要和标题内容，为其指定一个研究类别。",

    "给出以下论文信息，请判断所属学科门类。 Title = '{title}', Abstract = '{abstract}', Author List: '{authors}'.",

    "请问这篇文章属于哪个领域？标题是“{title}”，摘要如下：“{abstract}”。作者列表“{authors}”。",

    "我正在整理文献，不确定这篇论文的研究方向。你能帮我分类吗？信息如下。标题是“{title}”，摘要如下：“{abstract}”。作者列表“{authors}”。",

    "根据摘要“{abstract}”的内容，这篇题为“{title}” （作者列表“{authors}”）的论文应该归属哪个研究领域？",

    "我不太确定这篇文章的学科归属，可以请你判断一下吗？标题是“{title}”，摘要如下：“{abstract}”。作者列表“{authors}”。",

    "你是一位资深学术期刊编辑，请根据标题“{title}”、作者{authors}、摘要“{abstract}”为其确定研究方向。",

    "作为图书馆分类员，你需要为这篇论文分配一个学科分类。标题“{title}”、作者{authors}、摘要“{abstract}”。",

    "请模拟审稿人角色，为该论文选择一个最合适的研究领域。标题“{title}”、作者{authors}、摘要“{abstract}”。",

    "标题“{title}”、作者{authors}、摘要“{abstract}”。 请模拟审稿人角色，为该论文选择一个最合适的研究领域。",

    "从摘要“{abstract}”中的关键词判断，该论文属于哪一类学科？额外的信息：标题“{title}”、作者{authors}。",

    "从研究目标和方法出发，请为该论文做出领域归属判断。标题“{title}”、作者{authors}、摘要“{abstract}”。",

    "通过标题“{title}”及其对应的研究内容“{abstract}”，推断其最可能的研究方向。作者列表：“{authors}”。",

    "[系统请求] 输入论文元信息：标题“{title}”、作者{authors}、摘要“{abstract}”。请进行自动分类。",

    "[分类助手] 请为该论文分配一个领域标签。标题“{title}”、作者{authors}、摘要“{abstract}”。",

    "[AI 分类引擎] 任务输入：{title}，摘要：{abstract}。请输出所属学科。作者列表：“{authors}”。",

    "如果你只读了以下论文摘要“{abstract}”和标题“{title}”，（作者列表你可能不关心：“{authors}”）你会认为它属于哪个领域？",

    "假设你是一个“论文归类机器人”，你的任务是为这篇论文打上一个准确的学科标签。标题“{title}”、作者{authors}、摘要“{abstract}”。",

    "[System Instruction] Paper classification task initiated. Input: title '{title}', authors {authors}, abstract '{abstract}'. Please assign an appropriate research domain label.",

    "[MetadataClassifier::Invoke] -> Analyze the paper with metadata {title}, {authors}, and {abstract}. Output: scientific discipline.",

    "[Task: ResearchFieldDetection] Paper metadata received. Begin classification using the abstract and title.\n> Title: '{title}'\n> Authors: {authors}\n> Abstract: '{abstract}'",

    "[CLASSIFY_PAPER] Inputs:\n- TITLE = '{title}'\n- AUTHORS = {authors}\n- ABSTRACT = '{abstract}'\n→ RETURN: FIELD_LABEL",

    "[System Input] A new research paper has been submitted. Please determine the academic category based on:\n• Title: '{title}'\n• Authors: {authors}\n• Abstract: '{abstract}'",

    "【系统指令】已接收到论文元数据。请根据标题“{title}”、作者{authors}和摘要“{abstract}”，判定所属学科领域。",

    "【研究领域分类模块】接收到一篇新论文，请根据摘要与标题内容进行自动归类。\n→ 论文信息：{title}，{authors}，{abstract}",

    "[调用接口：学科分类] 参数如下：标题：{title}作者：{authors}摘要：{abstract}→ 返回值：学术领域标签"

]

options = "A. quant-ph\nB. physics.chem-ph\nC. physics.atom-ph\nD. cond-mat.soft\nE. cs.RO\nF. cs.CL\nG. cs.SE\nH. cs.IR\nI. hep-th\nJ. hep-ph\nK. physics.optics\nL. cs.AI\nM. cs.CV\nN. nucl-th\nO. astro-ph\nP. math.PR\nQ. cs.OS\nR. eess.SP\nS. math.OC\nT. math.DS\nU. math.DG\nV. math.MP\nW. cs.MM\nX. stat.ME\nY. math.CO\nZ. cs.NE"
# options = "A. 量子物理 quant-ph\nB. 化学物理 physics.chem-ph\nC. 原子物理 physics.atom-ph\nD. 软凝聚态物理 cond-mat.soft\nE. 机器人学 cs.RO\nF. 计算语言学 cs.CL\nG. 软件工程 cs.SE\nH. 信息检索 cs.IR\nI. 高能理论物理 hep-th\nJ. 高能现象学 hep-ph\nK. 光学 physics.optics\nL. 人工智能 cs.AI\nM. 计算机视觉 cs.CV\nN. 核理论 nucl-th\nO. 天体物理 astro-ph\nP. 概率论 math.PR\nQ. 操作系统 cs.OS\nR. 信号处理 eess.SP\nS. 最优化与控制 math.OC\nT. 动力系统 math.DS\nU. 微分几何 math.DG\nV. 数学物理 math.MP\nW. 多媒体 cs.MM\nX. 统计方法 stat.ME\nY. 组合数学 math.CO\nZ. 神经与进化计算 cs.NE"

# author_template = []

instruction_templates = [
    "You are an AI academic librarian trained to classify research papers with 99%\ accuracy.",
    "[SYSTEM ROLE] Domain Classification Officer\n Mission: Categorize the paper",
    "你是个优秀的论文分类师",
    "As a meta-reviewer AI, you must:\n1. Identify 4 key terms from title of the paper\n2. Cross-check with authors publication history\n3. Map abstract to the most ralted subfileds",
    "By academic protocol GPT-2025, you are required to\n1. Disclose uncertainty if abstract is ambiguous\n2. Prioritize author-specified keywords in title\n3. Identify the most ralted subfileds",
    "Task: Teach a graduate student how to classify title.\nSteps:\na) Highlight disciplinary cues in abstract\nb) Explain why authors affiliations suggest _____ field\nc) Conclude with the option [A-Z Arxiv field code]",
    "[AI CLASSIFIER v3.1 INPUT]\nTitle: title\nAuthors: authors\nAbstract: abstract\nPROCESSING...\nOUTPUT: [A-Z Arxiv code]",
    "As an ethical AI classifier, you MUST:\nAvoid overgeneralization (e.g., 'Engineering' is too broad)\nCite classification rationale from abstract\nExample output: [Arxiv field code]",
    "[URGENT PEER REVIEW REQUEST] Deadline: 10s to classify title (authors) for conference track assignment. Abstract snapshot: abstract. Respond ONLY with track option from provided list.",
    "你是一名学术档案管理员，需根据《Arxiv图书馆分类法》根据题目、作者和摘要内容对论文进行精准分类。并输出Arixv分类代码",
    "[系统指令] 国家自然科学基金委AI评审员  任务：依据标题、作者及摘要，从申请代码A-Z中选择最匹配的子领域",
    "作为学术审计AI，你必须：\n① 从摘要提取方法论关键词\n② 核对authors在Scopus的研究主题\n③ 对照 A-Z 的《学科分类与代码》\n最终输出分类代码：",
    "根据《AI科研分类规范》2024版：\n标题中的'研究'/'分析'等词不得作为分类依据\n需明确摘要中的3处领域特征\n输出包含 A-Z 的分类代码",
    "假设你是一个“论文归类机器人”，你的任务是为这篇论文打上一个准确的学科标签。",
    "[分类助手] 请为该论文分配一个领域标签。",
    "从研究目标和方法出发，请为该论文做出领域归属判断。",
    "从摘要和题目中的关键词判断，该论文属于哪一类学科？",
    "作为图书馆分类员，你需要从摘要和题目中的关键词判断为这篇论文分配一个学科分类。",
    "请模拟审稿人角色，为该论文选择一个最合适的研究领域，可以从摘要和题目进行判断。",
    "作为论文资深读者，你可以通过论文元信息判断所属学科门类。",
    "This paper was submitted for classification. Use the metadata to determine the category.",
    "Generate a domain label based on the core ideas from the abstract and title provided.",
]

option_map = {"A": "quant-ph", "B": "physics.chem-ph", "C": "physics.atom-ph", "D": "cond-mat.soft", "E": "cs.RO", "F": "cs.CL",
            "G": "cs.SE", "H": "cs.IR", "I": "hep-th", "J": "hep-ph", "K": "physics.optics", "L": "cs.AI", "M": "cs.CV", "N": "nucl-th",
            "O": "astro-ph", "P": "math.PR", "Q": "cs.OS", "R": "eess.SP", "S": "math.OC", "T": "math.DS", "U": "math.DG", "V": "math.MP",
            "W": "cs.MM", "X": "stat.ME", "Y": "math.CO", "Z": "cs.NE"}
get_options = dict(zip(option_map.values(), option_map.keys()))

other_option_map = {}
for category in get_options.keys():
    other_categories = set(option_map.values())
    other_categories.remove(category)
    other_option_map[category] = other_categories

def preprocess_arxiv_json(input_jsonl_file, output_jsonl_file):
    """
    Preprocess the arXiv JSONL file to extract and save the 'title', 'abstract' 
    and other fields to build a sft dataset for a category.

    Args:
        input_jsonl_file (str): Path to the input JSONL file.
        output_jsonl_file (str): Path to the output JSONL file.
    """
    papers = dict(zip(option_map.values(), [list() for _ in option_map.values()]))
    with open(input_jsonl_file, 'r', encoding='utf-8') as f:
        for line in f:
            item = json.loads(line)
            title = item.get('title', '')
            authors: str = item.get('authors', '')
            abstract: str = item.get('abstract', '')
            categories: str = item.get('categories', '')
            # if categories.startswith(category):
            for category in papers.keys():
                if category in categories and not any(c in categories for c in other_option_map[category]): # 排除交集样本
                    instruction = random.choice(instruction_templates)
                    input_text = random.choice(input_templates).format(title=json.dumps(title), authors=json.dumps(authors), abstract=json.dumps(abstract))
                    # if random.randint(0, 1) == 0:
                    #     input_text = input_text + '\n\n' + options
                    # else:
                    #     input_text = options + '\n\n' + input_text
                    input_text = input_text + '\n\n' + options
                    output = get_options[category]
                    papers[category].append({"instruction": instruction, "input": input_text, "output": output})
                    break

    for category in papers.keys():
        cnt = 0
        output_file = os.path.join(output_base_dir, f"{category}.jsonl")
        with open(output_file, 'w', encoding='utf-8') as out_f:
            for item in papers[category]:
                out_f.write(json.dumps(item, ensure_ascii=False))
                out_f.write('\n')
                out_f.flush()
                cnt += 1
        print(f'{category}: {cnt}')

def fix_category(input_jsonl_file, output_jsonl_file, category, repeat_to=0, judge_rule=lambda x, y: x.startswith(y), open_mode='w', exclude_multi=True):

    cnt = 0
    if open_mode != 'w':
        with open(output_jsonl_file, 'r', encoding='utf-8') as out_f:
            cnt = len(out_f.readlines())

    def _fix_category(input_jsonl_file, output_jsonl_file, category):
        nonlocal cnt

        # 补充 Q，V, W 类
        with open(input_jsonl_file, 'r', encoding='utf-8') as f, open(output_jsonl_file, open_mode, encoding='utf-8') as out_f:
            data = []
            for line in f:
                item = json.loads(line)
                title = item.get('title', '')
                authors: str = item.get('authors', '')
                abstract: str = item.get('abstract', '')
                categories: str = item.get('categories', '')
                if exclude_multi and any(c in categories for c in other_option_map[category]): # 排除交集样本
                    continue
                # if categories.startswith(category):
                if judge_rule(categories, category):
                    categories = category
                    if categories == 'math-ph':
                        categories = 'math.MP'
                    instruction = random.choice(instruction_templates)
                    input_text = random.choice(input_templates).format(title=json.dumps(title), authors=json.dumps(authors), abstract=json.dumps(abstract))
                    input_text = input_text + '\n\n' + options
                    output = get_options[categories]
                    item = json.dumps({"instruction": instruction, "input": input_text, "output": output}, ensure_ascii=False)
                    data.append(item)
            for item in data:
                out_f.write(item)
                out_f.write('\n')
                cnt += 1
    
    _fix_category(input_jsonl_file, output_jsonl_file, category)
    while cnt < repeat_to:
        _fix_category(input_jsonl_file, output_jsonl_file, category)
    print(f'after fix, {category}: {cnt}')
    

def cnt_in_filename(basedir: str):
    for fname in os.listdir(basedir):
        if fname.endswith('jsonl'):
            num = 0
            with open(os.path.join(output_base_dir, fname), 'r') as f:
                num = len(f.readlines())
            # os.rename(os.path.join(basedir, fname), os.path.join(basedir, f"{fname.removeprefix(('.jsonl'))}_{num}.jsonl"))
            os.rename(os.path.join(basedir, fname), os.path.join(basedir, f"{fname.replace('.jsonl.jsonl', '.jsonl')}"))

def gather(basedir: str, sample_num_class):
    cnt = 0
    with open('arxiv_20k_rich.jsonl', 'w') as out_f:
        for fname in os.listdir(basedir):
            if fname.endswith('jsonl'):
                data = []
                with open(os.path.join(output_base_dir, fname), 'r') as f:
                    data = f.readlines()
                data = random.sample(data, min(sample_num_class, len(data)))
                for line in data:
                    out_f.write(line)
                out_f.flush()
                print(f'{fname}: {len(data)}')
                cnt += len(data)
    print(f'total {cnt}')
            

if __name__ == "__main__":

    print(f"""
        系统提示词模板数量：{len(instruction_templates)}
        用户提示词模板数量：{len(input_templates)}
          """)

    arxiv_json_file = 'd:/data/arxiv-metadata-oai-snapshot.json'
    # arxiv_json_file = './test.jsonl'
    output_json_file = './arxiv_sftdata.jsonl'

    # 归类单类别论文
    # preprocess_arxiv_json(arxiv_json_file, output_json_file)

    """
    quant-ph: 75119
    physics.chem-ph: 5999
    physics.atom-ph: 6848
    cond-mat.soft: 14530
    cs.RO: 15943
    cs.CL: 32125
    cs.SE: 10743
    cs.IR: 5137
    hep-th: 60558
    hep-ph: 83572
    physics.optics: 17736
    cs.AI: 12987
    cs.CV: 74045
    nucl-th: 19846
    astro-ph: 86911
    math.PR: 25289
    cs.OS: 347          问题：稀少 cs.OS only (347); cs.OS contains (565); new primary (1060); total (2174)
    eess.SP: 11193
    math.OC: 19764
    math.DS: 14277
    math.DG: 17389
    math.MP: 0          问题：别名 math-ph；交叉主题多（）            
    cs.MM: 1087         问题：交叉主题多（cs.CV、 cs.AI）               # 考虑尽量少选 2018 年以前的，避免交叉  primary (32848)
    stat.ME: 12315
    math.CO: 32513
    cs.NE: 2904         问题：较少；交叉主题多（cs.CV、 cs.AI）
    """

    # 处理特别类
    output_Q_json_file = os.path.join(output_base_dir, "cs.OS.jsonl")
    output_V_json_file = os.path.join(output_base_dir, "math.MP.jsonl")
    output_W_json_file = os.path.join(output_base_dir, "cs.MM.jsonl")
    # fix_category(arxiv_json_file, output_Q_json_file, 'cs.OS', judge_rule=lambda categories, category: category in categories, open_mode='w')                     # Q 1114
    # fix_category('arxiv_cs.OS_1120.jsonl', output_Q_json_file, 'cs.OS', judge_rule=lambda categories, category: True, open_mode='a', exclude_multi=True)            # Q 2174    有重复
    # fix_category(arxiv_json_file, output_V_json_file, 'math-ph', judge_rule=lambda categories, category: categories.startswith(category), open_mode='w')          # V 32848
    # fix_category(arxiv_json_file, output_W_json_file, 'cs.MM', judge_rule=lambda categories, category: categories.startswith(category), open_mode='w')            # W 2469 不去除交叉
    # fix_category('arxiv_cs.MM_5012.jsonl', output_W_json_file, 'cs.MM', judge_rule=lambda categories, category: True, open_mode='a', exclude_multi=True)            # W 1726 去除交叉 未使用

    # 归集
    gather(basedir=output_base_dir, sample_num_class=20000)

    # 计数
    # cnt_in_filename(basedir=output_base_dir)
]]> <h2 id="写在前面"><a class="markdownIt-Anchor" href="#写在前面"></a> 写在前面</h2> <p><a class="link" href="https://aicarrier.feishu.cn/wiki/Gr7Iw6vhT