弱监督与半自动：标注函数设计

可视化演示

三步展示弱监督标注函数pipeline：函数类型与数据流、覆盖率与冲突处理、标签聚合与生成式去噪模型。

标注函数基础

想象你现在管理一家连锁餐厅，为了保证每一家分店出品稳定，你决定不再依赖主厨逐道品尝，而是把“什么算一道合格的菜”写成几条固定的检查规则：宫保鸡丁必须见到花生米，麻婆豆腐必须够麻够辣，一道菜看不出主料就要打回。每一条规则都不复杂，恰恰是这种朴素规则，成为整个弱监督体系的基石。

在机器学习的数据标注与管理中，这些规则就是“标注函数”（Labeling Function，简称 LF）。一个标注函数接收一条未标注的数据 x，返回一个“倾向性标签”，返回值只有三个：+1 表示“我倾向于这是正样本”，-1 表示“我倾向于这是负样本”，0 表示“这条规则拿不准，弃权”。多个标注函数组成一个“规则集合”，像一组各持己见的试吃员。

为什么这是弱监督的核心？传统监督学习要求每条数据都有人工标签，而弱监督用大量便宜的规则代替昂贵的人力，先给所有数据粗略打标，再用聚合步骤把噪声消掉。标注函数天然是启发式规则：它不一定每一条都正确，但每一条都携带了领域经验。在设计时，一条规则命中一种可解释的模式，比如“出现'退款'就倾向投诉类工单”，这比一个黑箱模型更容易被检验和迭代。

$$\displaystyle \Lambda_j(x) \in \{-1, 0, +1\}$$

1. Λ（lambda）：希腊大写字母 lambda，这里表示一条标注函数，也就是后厨里的一条试吃规则。

$$\Lambda_j$$

2. 下标 j：规则的编号，如主厨A、主厨B、主厨C，对应第 j 条具体规则。

$$j \in \{1, 2, \dots, m\}$$

3. x：一条输入样本，比如一份宫保鸡丁的出品描述文本，或任意一条待标注数据。

$$x \in X$$

4. {-1, 0, +1} 三值集合：输出被限制在三个值中，+1 表示正例倾向，-1 表示负例倾向，0 表示弃权；LF 不允许输出 2 或 0.5 这类模糊值，这是它与普通打分函数最本质的区别。

$$\Lambda_j(x) = 1 \quad \text{或} \quad -1 \quad \text{或} \quad 0$$

回到餐厅的比喻：每条试吃规则都只回答一个简单问题——“这条菜够不够格？”它可能看走眼，但至少给了方向。几十条这样的规则放在一起，就构成了弱监督系统的“经验库”，这正是后续所有聚合与优化动作的起点。

模板函数设计

餐厅里每位试吃员的特长不一样：有人擅长认食材，一眼就能看出有没有花生；有人擅长看摆盘，能从描述文字的格式里读出信息；还有人手边有一本厚厚的“食材档案册”，随手一翻就能查表。设计标注函数也是同样的道理——围绕不同数据形态，形成了若干可复用的模板。

最常用的模板是关键词匹配：数据文本中命中某个词，就给出一个倾向。例如文本中出现“退款”，就倾向标记为投诉工单。更复杂一点的是正则表达式，它不止匹配一个词，而是匹配一套模式，比如“13 位手机号”“订单号 ZX 开头加 8 位数字”这种模式，用正则表达式可以精准取值。此外还有知识库查询：把黑名单词库、领域词典、地理信息表等外部数据引入，命中即触发；以及模型辅助：复用已经训练好的小模型或外部 API 的输出，把模型的预测当作一个新的“试吃员”。

在实际部署中，这些模板常常互相叠加。比如判断一条菜品评价是否合格，“主料缺失”用关键词，而“疑似过火”可能用正则匹配“焦|糊”这类字眼。为了让模板组合更可控，工程师通常会给每个关键词设计权重，再用加权求和的方式把多条规则的判断合成一个分数。下面这个公式就是关键词匹配模板的典型打分方式：

$$\displaystyle \text{score}(x) = \sum_{k} \mathbb{1}(t_k \in x) \cdot w_k$$

1. 特征词 \(t_k\)：第 k 个我们关注的关键词，如“花生”、“辣”、“退款”。

$$t_k \in \{ \text{'花生'}, \text{'辣'}, \text{'退款'}, \dots \}$$

2. 指示函数 \(\mathbb{1}(\cdot)\)：括号内条件成立取 1，不成立取 0。这个词出现了，就贡献一份力量；没出现，就完全沉默。

$$\mathbb{1}(t_k \in x) = 1 \quad \text{当且仅当} \quad t_k \in x$$

3. 权重 \(w_k\)：这个词对标签的“话语权”，正权重把分数推向正例，负权重把分数推向负例，权重绝对值越大越有影响力。

$$w_k \in \mathbb{R}$$

4. 求和 \(\sum\)：把所有命中词的贡献累加，最终 score 大于 0 则取正标签，小于 0 取负标签，等于 0 则弃权。

$$\text{score}(x) = w_{a} + w_{b} + w_{c} + \dots$$

回到餐厅：关键词模板就像“看到花生就给宫保鸡丁加一分”，正则模板像“只要描述里有 13 位数字就怀疑是订餐电话”，知识库模板则像掏出食材档案核对产地。设计标注函数时，优先选模板，把领域知识翻译成这些可解释、可复用的“试吃动作”，就能快速建起一个初版规则库。

覆盖与准确率

规则库搭起来了，你却发现另一个麻烦：主厨写的规则有的太严，比如“必须见到花生米”只对宫保鸡丁有效，其他菜全部弃权，导致大量菜品无人评审；有的又太松，比如“有点辣就合格”，结果把大量不该合格的菜也放过了。这就是标注函数设计的核心矛盾——覆盖率与准确率之间的跷跷板。

覆盖率衡量的是：所有待标注数据中，有多少比例至少被一条规则“接住”（也就是没被全部弃权）。准确率衡量的则是：被接住的那部分数据里，规则给出的倾向到底靠不靠谱。二者往往不可兼得：规则越宽，覆盖率高但误判多；规则越窄，准确率高但大量数据没人管。评估一条规则好不好，不能只看它自己，还要看它在整个数据集上的覆盖表现。

在实际工程中，覆盖率是第一个要监控的指标。如果覆盖率为 60%，意味着剩下 40% 的数据无法自动标注，只能走人工或放弃。围绕覆盖率，还需要同时记录冲突比率——有多少数据同时被正负方向的规则命中，冲突率越高，说明规则之间越缺乏一致性，聚合阶段的压力也越大。

$$\displaystyle \text{coverage} = \frac{|\{x \in D : \Lambda(x) \neq 0\}|}{|D|}$$

1. 数据集 D：全部待标注数据集合，就像餐厅今天需要评审的所有菜品。

$$D = \{x_1, x_2, \dots, x_N\}$$

2. 条件 \(\Lambda(x) \neq 0\)：表示至少有一条标注函数在这个样本上没有弃权，也就是这条数据被规则集合“接住”了。

$$\Lambda(x) = \max_j |\Lambda_j(x)| \neq 0$$

3. 集合基数 \(|\cdot|\)：统计满足条件的样本个数。分子算出“被覆盖的样本数”，分母是总样本数。

$$|\{x \in D : \Lambda(x) \neq 0\}|$$

4. 比值：两者相除得到 0 到 1 之间的覆盖率。覆盖率为 0.8，就说明 80% 的数据可以走自动标注。

$$0 \leq \text{coverage} \leq 1$$

回到餐厅的场景：覆盖率就是“今天有多少菜能被试吃规则评审”，准确率则是“评审出来的合格/不合格，到底有多少是对的”。好的规则库设计，不是追求单条规则 100% 正确，而是让整个规则集合覆盖更多菜品，同时保持整体评审可信。为此，需要用一个小规模人工精标集来当“裁判”，持续称量这个跷跷板。

标签冲突消解

餐厅里最热闹的时刻，是三位试吃员吵起来了：主厨 A 看到花生，说这菜合格；主厨 B 尝了一口，觉得辣度不够，说退回；主厨 C 犹豫半天，干脆弃权。同一道菜，三个意见互不相同，到底听谁的？这就是标注函数设计里最经典的“标签冲突”问题。

最简单的消解策略是多数投票：把每条规则的输出相加，正票多于负票就取正标签，负票多就取负标签，恰好打平则视为“低置信”，送去人工复核。多数投票虽然朴素，但理论保证很强——只要各条规则的错误互相独立，规则越多，投票结果越可靠。进一步可以引入加权表决：给那些历史上更准确的规则更高的权重，让“资深试吃员”有更大的话语权。

更高级的做法是用生成模型来聚合。这类模型把每条规则看成一个“带噪的标注器”，通过观察它们在不同数据上的输出模式，估计出每条规则的准确率和倾向性，再反过来计算每个样本是正例的概率。这种方法的优势在于：它不把投票当平权，而是真的学会“谁更可靠”。最终，聚合器还会输出一个置信度分数，低置信度的样本专门留给人工处理。

$$\displaystyle \hat{y} = \operatorname{sign}\left(\sum_{j=1}^{m} \Lambda_j(x)\right)$$

1. 求和 \(\sum_{j=1}^{m}\)：把 m 位试吃员的意见全部相加。+1 是赞成，-1 是反对，0 是弃权。

$$\sum_{j=1}^{m} \Lambda_j(x) = \Lambda_1(x) + \Lambda_2(x) + \cdots + \Lambda_m(x)$$

2. 符号函数 sign：输入为正数取 +1，为负数取 -1，恰好为 0 取 0。

$$\operatorname{sign}(z) = \begin{cases} +1 & z > 0\\ -1 & z < 0\\ 0 & z = 0 \end{cases}$$

3. 最终标签 \(\hat{y}\)：聚合结果，即多数表决后的弱标签，对应最终写在数据上的“合格/退回/复核”。

$$\hat{y} \in \{-1, 0, +1\}$$

加权表决的公式也很好理解：给每条规则乘以权重 \(w_j\)，就相当于有些试吃员一票顶两票：

$$\displaystyle \hat{y} = \operatorname{sign}\left(\sum_{j=1}^{m} w_j \Lambda_j(x)\right)$$

回到餐厅：多数投票就像“举手表决”，加权表决则是“让最有经验的主厨拥有更高票权”，而生成模型相当于在后台偷偷观察各位试吃员的历史战绩，自动调整他们的发言权。冲突并不可怕，它是信息，是规则库迭代的信号灯。

迭代优化流程

规则库不是写一次就能一劳永逸的。餐厅每周都会挑几道“样板菜”，请主厨亲自品尝并给出标准答案，再用这些标准答案去检验试吃员们的表现——哪条规则误判最多，哪条规则覆盖太窄，一目了然。这就是弱监督工程中最重要的迭代循环。

迭代的起点是错误分析。拿出金标集（人工精标的小样本），把聚合结果和人工标签逐条对比，找出系统性错误：是某条规则太激进，总是给出错误的正标签？还是规则之间相互冲突，导致原本正确的信号被抵消？经验表明，多数低质量规则库的问题不是“规则太少”，而是“规则太宽”。定位到具体问题规则后，进入第二步：增补或修改标注函数。可以收紧某个关键词的权重，也可以增加一条更精确的规则来覆盖之前漏掉的样本。

迭代的第三步是参数调优，包括调整投票阈值、规则权重、弃权判定标准等。最后一步是设“质量护栏”：在每次改动后用同一套金标集重新评估，只有整体准确率和覆盖率都达到预设阈值的改动才被保留。这个流程需要循环执行，直到指标稳定。

$$\displaystyle \text{acc}_{\text{agg}} = \frac{1}{|G|} \sum_{x \in G} \mathbb{1}(\hat{y}(x) = y^{*}(x))$$

1. 金标集 G：一小批由领域专家人工标注、可信度极高的样本，只用来做评估，不参与规则生成。

$$G = \{(x_1, y_1^{*}), (x_2, y_2^{*}), \dots\}$$

2. 真值标签 \(y^{*}(x)\)：专家给出的人工答案，是判断对错的唯一依据。

$$y^{*}(x) \in \{-1, +1\}$$

3. 指示函数 \(\mathbb{1}(\hat{y}(x) = y^{*}(x))\)：聚合标签与人工标签一致记 1，不一致记 0，从而统计出“多少样本被正确标注”。

$$\mathbb{1}(\text{matches}) = 1 \quad \text{matches} \quad \text{else} \quad 0$$

4. 平均 \(\frac{1}{|G|}\sum\)：把所有样本的正确率取平均，得到聚合器在金标集上的整体准确率。

$$\text{acc}_{\text{agg}} \in [0, 1]$$

回到餐厅的比喻：金标集就是“主厨亲自品尝过的样板菜”，每次改动试吃规则后都要重新上桌对比。一个成熟的弱监督系统，不是靠一次性灵感，而是靠这样一轮又一轮“分析—修改—评估”的迭代，逐渐逼近人工标注的质量上限。

半自动标注管线

最后一步，是把散落的规则、投票、人工复核组装成一条真正的流水线。餐厅的完整流程变成了这样：菜品从后厨出来 → 试吃员依照规则批量评审 → 几位试吃员意见一致就直接出结果 → 意见相左或信心不足的菜，送到主厨桌前人工复核 → 复核结论再回头优化规则。这条流水线，就是“半自动标注”的典型形态。

在工程实现上，这条管线首先需要一个“数据管线”：定时从数据库、日志或上游数据源抽取未标注数据，批量送入标注函数库执行。接着是“主动学习”环节：聚合模型除了给出标签，还给出置信度，管线自动挑选置信度最低、最让模型困惑的样本优先送人工。这样，有限的人力被集中花在最值得确认的数据上，而不是均匀浪费在所有样本上。

最后是反馈闭环：人工复核的结果不仅用于修正标签，还会回流到规则库和聚合模型中。比如某条规则频繁在人工复核中被推翻，系统就自动降低它的权重。这种“机器批量处理 + 人工关键兜底 + 反馈持续进化”的结构，让标注成本大幅下降，同时质量保持在可接受范围。

$$\displaystyle x^{*} = \arg\max_{x \in U} \left(1 - P(\hat{y} \mid x)\right)$$

1. 未标注集合 U：等待分派的“待评菜品”，是管线中还没有拿到明确标签的数据池。

$$U = \{x : x \in D, \text{未标注}\}$$

2. 置信度 \(P(\hat{y} \mid x)\)：聚合模型给出标签时附带的信心分数，越接近 1 越有把握。

$$P(\hat{y} \mid x) \in [0, 1]$$

3. 不确定度 \(1 - P\)：用 1 减去置信度，得到“困惑程度”，数值越大说明越需要人工介入。

$$1 - P(\hat{y} \mid x)$$

4. argmax：在所有样本中挑出不确定度最大的那一个，这就是主动学习“先审谁”的答案。

$$x^{*} = \text{最没把握的那条数据}$$

回看整条流水线：规则批量打标是“自动”，低置信和冲突样本送人工是“半自动”，复核结果回流优化是“闭环”。标注函数设计从来不止于写几个 if-else，它是一套完整的工程体系——用规则换取规模，用人工守住质量，用反馈持续进化，这就是弱监督与半自动标注留给数据工程最大的礼物。

AI 应用场景

Python 演示

import re class LabelingFunction:    """把一个函数包装成带名字的标注函数(LF)。     返回约定：+1 表示正标签，-1 表示负标签，0 表示弃权。    """     def __init__(self, name, fn):        self.name = name        self.fn = fn     def __call__(self, text):        return self.fn(text)  def lf_has_peanut(text):    return 1 if 'peanut' in text else 0  def lf_has_spicy(text):    return 1 if ('spicy' in text or 'numbing' in text) else 0  def lf_no_protein(text):    return -1 if not re.search(r'pork|chicken|fish|spareribs', text) else 0  def lf_tasty_word(text):    return 1 if 'taste' in text else 0  def lf_burnt(text):    return -1 if ('burnt' in text or 'scorch' in text) else 0  LFS = [    LabelingFunction('has_peanut', lf_has_peanut),    LabelingFunction('has_spicy', lf_has_spicy),    LabelingFunction('no_protein', lf_no_protein),    LabelingFunction('tasty_word', lf_tasty_word),    LabelingFunction('burnt', lf_burnt),] DISHES = [    'kung pao chicken, peanut crispy, spicy taste',    'mapo tofu, spicy and numbing',    'stir fried greens, light taste',    'braised pork, soft and tender',    'sweet sour spareribs, tangy sweet',    'boiled fish, oil smells burnt',] GOLD = [1, 1, 1, 1, 1, -1]  def aggregate(votes):    pos = votes.count(1)    neg = votes.count(-1)    if pos > neg:        return 1    if neg > pos:        return -1    return 0  def main():    n_labeled = 0    n_conflict = 0    correct = 0    for dish, gold in zip(DISHES, GOLD):        votes = [lf(dish) for lf in LFS]        label = aggregate(votes)        if votes.count(0) < len(votes):            n_labeled += 1        if votes.count(1) > 0 and votes.count(-1) > 0:            n_conflict += 1        if label == gold:            correct += 1        print('{0:<40} votes={1} label={2} gold={3}'.format(            dish, votes, label, gold))    print('coverage: {:.2f}'.format(n_labeled / len(DISHES)))    print('conflict: {:.2f}'.format(n_conflict / len(DISHES)))    print('accuracy: {:.2f}'.format(correct / len(DISHES)))  if __name__ == '__main__':    main()

1. class LabelingFunction:定义标注函数的包装类，给规则起名字、绑定执行函数。
2. def __call__(self, text):让规则对象可以像 lf(dish) 一样被直接调用，简化批量执行。
3. LFS = [...]把 5 条规则放进列表，构成规则库，也就是“试吃手册”。
4. votes = [lf(dish) for lf in LFS]每一条规则对同一条数据各投一票，得到一个投票向量。
5. if pos > neg: return 1多数表决：正票更多就返回 1，负票更多返回 -1，平局返回 0。
6. if votes.count(0) < len(votes): n_labeled += 1只要有一条规则没弃权，就算这条数据被覆盖。
7. if votes.count(1) > 0 and votes.count(-1) > 0: n_conflict += 1正负票同时存在，说明发生了规则冲突。
8. 'coverage: {:.2f}'.format(...)输出覆盖率、冲突率、准确率三项核心指标，帮助你判断规则库质量。

常见误区

面试题