一、问题背景:为什么我要认真做这次Prompt对比

上个月接了个内部需求:把公司招聘系统里积累的约1.2万条历史JD(职位描述)文本,抽取成结构化字段——职位名称、城市、经验年限、学历要求、薪资区间、技能关键词。这些JD全是HR从各个渠道复制粘贴来的,格式极其混乱:有的薪资写「15-25K·14薪」,有的写「年薪30万起」,有的干脆不写;技能关键词有的用顿号分隔,有的用换行,有的混在句子里。

最初我的想法很简单,直接调API让模型输出JSON就完了。结果第一版Prompt上线测试,200条样本里只有142条能被json.loads()正常解析,字段准确率71.2%,还有若干条把「3-5年」理解成「3.5年」这种离谱错误。

这时候我意识到,Prompt Engineering不是玄学,它是有明确投入产出比的工程问题:多花多少Token、换回多少准确率、解析失败率能不能压到可接受范围。于是我系统性地做了12组对比实验,把过程和结论记下来。

二、环境与版本

实验环境固定如下,避免变量污染:

  • Python 3.11.6
  • openai==1.51.0(调用 gpt-4o-mini,model 快照 gpt-4o-mini-2024-07-18)
  • anthropic==0.34.2(调用 claude-3-5-haiku-20241022)
  • 温度统一 temperature=0.0,max_tokens=1024
  • 样本:200条真实JD,人工标注了6个字段的ground truth
  • 评测脚本自写,字段级精确匹配(薪资区间做归一化后比较)

选 gpt-4o-mini 是因为便宜(输入 $0.15/1M tokens,输出 $0.60/1M tokens),适合大批量跑;Claude 3.5 Haiku 输入 $0.80/1M、输出 $4/1M,贵一些但做对照。

三、方案设计:12组Prompt怎么分组

我把变量拆成四个维度,组合出12组有代表性的Prompt:

  1. P1 Zero-shot 裸提示:就一句「提取以下字段,输出JSON」。
  2. P2 角色设定:「你是一位资深HR数据分析师……」+ P1。
  3. P3 字段说明细化:对每个字段给出定义和取值示例。
  4. P4 JSON Schema 约束:给出完整schema,要求严格按schema输出。
  5. P5 Few-shot 1例:P4 + 1条输入输出示例。
  6. P6 Few-shot 2例:P4 + 2条示例(覆盖不同薪资写法)。
  7. P7 Few-shot 3例:P4 + 3条示例。
  8. P8 CoT:要求「先分析再输出」,最后附JSON。
  9. P9 CoT + Schema:P8 + P4。
  10. P10 负面约束:P6 + 「不要编造原文没有的信息,缺失填null」。
  11. P11 输出格式强约束:P10 + 「只输出JSON,不要markdown代码块,不要解释」。
  12. P12 P11 + 自校验:要求模型输出前自查字段是否齐全。

评测指标:字段准确率(6字段平均)、JSON可解析率、平均输入Token、平均输出Token、单条成本。

四、核心实现(含代码)

先看Prompt构造和调用的核心代码。这里用P6(Schema+2 Few-shot)作为示例,其他组通过参数切换:

import json, time
from openai import OpenAI

client = OpenAI(api_key="sk-xxx")

SCHEMA = {
    "job_title": "string, 职位名称,去除薪资和城市信息",
    "city": "string, 工作城市,多个用/分隔",
    "experience": "string, 经验要求,如'3-5年',无要求填'不限'",
    "education": "string, 最低学历,如'本科',未写填null",
    "salary": "string, 归一化为'最低K-最高K',年薪换算为月薪,无则null",
    "skills": "array[string], 技能关键词,最多8个"
}

FEW_SHOT = [
    {
        "input": "急招Java开发!坐标杭州,3-5年经验,本科以上,20-35K·14薪,熟悉Spring Cloud、MySQL、Redis。",
        "output": {"job_title": "Java开发", "city": "杭州", "experience": "3-5年",
                   "education": "本科", "salary": "20K-35K",
                   "skills": ["Spring Cloud", "MySQL", "Redis"]}
    },
    {
        "input": "北京 数据分析师 年薪30万起 硕士 会用SQL/Python/Tableau 经验不限",
        "output": {"job_title": "数据分析师", "city": "北京", "experience": "不限",
                   "education": "硕士", "salary": "25K-25K",
                   "skills": ["SQL", "Python", "Tableau"]}
    }
]

def build_prompt(jd: str, mode: str = "P6") -> str:
    schema_str = json.dumps(SCHEMA, ensure_ascii=False, indent=2)
    parts = []
    if mode in ("P2", "P3", "P4", "P5", "P6", "P7", "P10", "P11", "P12"):
        parts.append("你是一位资深HR数据分析师,擅长从非结构化文本中抽取结构化信息。")
    if mode in ("P3", "P4", "P5", "P6", "P7", "P10", "P11", "P12"):
        parts.append(f"请从下面的招聘JD中抽取字段,字段定义如下:\n{schema_str}")
    else:
        parts.append("请从下面的招聘JD中抽取职位名称、城市、经验、学历、薪资、技能,输出JSON。")
    if mode in ("P5", "P6", "P7", "P10", "P11", "P12"):
        n = {"P5": 1, "P6": 2, "P7": 3}.get(mode, 2)
        for ex in FEW_SHOT[:n]:
            parts.append(f"示例输入:{ex['input']}\n示例输出:{json.dumps(ex['output'], ensure_ascii=False)}")
    if mode in ("P8", "P9"):
        parts.append("请先逐步分析文本中的关键信息,再给出最终JSON。")
    if mode in ("P10", "P11", "P12"):
        parts.append("不要编造原文没有的信息,缺失字段填null。")
    if mode in ("P11", "P12"):
        parts.append("只输出JSON对象本身,不要markdown代码块,不要任何解释文字。")
    if mode == "P12":
        parts.append("输出前自查:6个字段是否齐全,薪资是否已归一化。")
    parts.append(f"待抽取JD:\n{jd}")
    return "\n\n".join(parts)

def call_model(prompt: str, model: str = "gpt-4o-mini"):
    t0 = time.time()
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        temperature=0.0,
        max_tokens=1024,
    )
    return {
        "text": resp.choices[0].message.content,
        "in_tokens": resp.usage.prompt_tokens,
        "out_tokens": resp.usage.completion_tokens,
        "latency": round(time.time() - t0, 2),
    }

评测脚本的关键是「宽容解析 + 严格比对」:解析时先尝试直接json.loads,失败则去掉``json围栏再试,再失败则用正则抓第一个{...}`。比对时薪资做归一化(年薪÷12),技能做集合比较:

import re

def parse_json_safe(text: str):
    text = text.strip()
    for attempt in (text, re.sub(r"^```(json)?|```$", "", text, flags=re.M).strip()):
        try:
            return json.loads(attempt), True
        except Exception:
            continue
    m = re.search(r"\{.*\}", text, re.S)
    if m:
        try:
            return json.loads(m.group(0)), True
        except Exception:
            pass
    return None, False

def norm_salary(s):
    if not s or s == "null":
        return None
    nums = [float(x) for x in re.findall(r"\d+(?:\.\d+)?", str(s))]
    if not nums:
        return None
    if "年" in str(s) and "K" not in str(s).upper():
        nums = [n / 12 for n in nums]
    return (min(nums), max(nums)) if len(nums) >= 2 else (nums[0], nums[0])

def score_one(pred: dict, truth: dict) -> dict:
    fields = ["job_title", "city", "experience", "education", "salary", "skills"]
    hit = {}
    for f in fields:
        p, t = pred.get(f), truth.get(f)
        if f == "salary":
            hit[f] = norm_salary(p) == norm_salary(t)
        elif f == "skills":
            ps = set(x.lower() for x in (p or []))
            ts = set(x.lower() for x in (t or []))
            hit[f] = len(ps & ts) / max(len(ts), 1) >= 0.6
        else:
            hit[f] = (str(p).strip() if p else None) == (str(t).strip() if t else None)
    return hit

五、踩坑与优化记录

坑1:CoT把输出撑爆了。 P8要求「先分析再输出」,平均输出Token从P1的98涨到312,更麻烦的是模型经常在分析里写一半JSON、最后又写一遍完整JSON,我的正则抓到的是第一段残缺JSON,解析失败率飙到11%。教训:CoT适合推理类任务,抽取类任务里它是纯粹的Token浪费。

坑2:Few-shot不是越多越好。 P5→P6准确率涨了7个点,P6→P7几乎没涨(94.5%→94.8%),但输入Token从平均412涨到556。2条示例是拐点,第3条开始边际收益趋近于零。而且示例的选择比数量重要——我最初两条示例薪资写法太像,模型遇到「年薪30万起」就懵,换成一条月薪一条年薪后才解决。

坑3:Schema里的字段说明会互相打架。 我一开始把salary定义成「薪资区间字符串」,模型有时输出「20-35K」有时输出「20K-35K」,归一化脚本要写两套。后来在Schema里直接写死格式「最低K-最高K」,一致性问题消失。

坑4:temperature=0不等于完全确定。 同一批样本重跑两次,gpt-4o-mini有约1.5%的字段输出不同(主要是skills的排序和同义词选择)。所以评测必须跑全量200条取平均,不能抽样几条看看就下结论。

坑5:Claude对「只输出JSON」的服从性更好。 P11在Claude 3.5 Haiku上可解析率100%,在gpt-4o-mini上是98.5%——有3条还是带了「好的,以下是提取结果:」的前缀。对OpenAI模型,加一句「你的回复第一个字符必须是{」比反复强调「不要解释」更管用。

六、效果数据

200条样本、gpt-4o-mini、temperature=0 的结果(准确率为6字段平均,成本按官方单价估算):

组 字段准确率 可解析率 平均输入Token 平均输出Token 单条成本(USD)
P1 Zero-shot 71.2% 71.0% 156 98 $0.000082
P2 角色设定 73.5% 74.5% 178 101 $0.000087
P3 字段说明 84.1% 88.0% 342 112 $0.000118
P4 Schema 87.6% 93.5% 368 108 $0.000120
P5 Few-shot 1 91.3% 97.0% 412 110 $0.000128
P6 Few-shot 2 94.5% 98.5% 512 112 $0.000144
P7 Few-shot 3 94.8% 98.5% 556 113 $0.000152
P8 CoT 86.9% 89.0% 402 312 $0.000248
P9 CoT+Schema 90.2% 92.5% 588 298 $0.000269
P10 负面约束 94.9% 98.5% 548 110 $0.000148
P11 格式强约束 94.7% 98.5% 566 108 $0.000151
P12 自校验 94.6% 99.0% 592 121 $0.000158

几个结论:

  1. Schema约束是性价比最高的一步:P1→P4,Token只涨1.5倍,准确率涨16.4个点,可解析率从71%到93.5%。
  2. P6是甜点位:相比P1,单条成本从$0.000082涨到$0.000144(+75%),但准确率从71.2%到94.5%。按1.2万条算,总成本从$0.98涨到$1.73,多花不到1美元换23个点准确率,没有任何犹豫的理由。
  3. CoT在这个任务上是负优化:P8成本是P6的1.7倍,准确率还低7.6个点。抽取任务别迷信CoT。
  4. P10/P11/P12相对P6的提升在噪声范围内(±0.4个点),但P11把gpt-4o-mini的格式服从性从98.5%稳住了,P12的可解析率99.0%是最高的,代价是输入Token多80。最终我选了P11作为生产版本。
  5. Claude 3.5 Haiku对照:P11下准确率95.1%、可解析率100%,但单条成本约$0.00058,是gpt-4o-mini的3.8倍。1.2万条全量跑,差价约$5,其实也能接受,但gpt-4o-mini已经够用,就没换。

最终生产配置:P11 + gpt-4o-mini + temperature=0 + max_tokens=512(实测输出从没超过200,砍到512省不了钱但能防跑飞),1.2万条全量跑完耗时约2.1小时(并发8),总花费约$1.81,人工抽检200条准确率94.5%,剩余5.5%的误差主要集中在「经验不限」和缺失字段的null判断上,属于标注本身就有歧义的边界case。

七、总结

这次实验最大的收获不是找到了某个「神级Prompt」,而是建立了量化对比的习惯:每次改Prompt都跑同一批200条样本,记录准确率、可解析率、Token三件套。几个可以直接复用的经验:

  • 抽取类任务,Schema约束优先于角色设定,Few-shot 2条是性价比拐点;
  • CoT留给推理任务,抽取任务用它基本是花钱买噪音;
  • 格式服从性要用「正向指令」(第一个字符必须是{)而不是反复说「不要」;
  • temperature=0也要跑全量评测,1%-2%的波动足以让你的A/B结论翻车。

Prompt Engineering说到底是个优化问题:在Token预算约束下最大化输出质量。把这几个数字摆在台面上,跟老板汇报和跟同事review都硬气得多。代码和样本标注脚本我整理在内部仓库了,有需要可以找我要。