Prompt 工程实战总结：文本分类、信息抽取、语义匹配

一、背景

本文基于 Ollama + Qwen2:0.5b 本地模型 ，完成了三个经典的 NLP 任务：

(另附了基于langchain_openai的ChatOpenAI配合deepseek线上大模型接口处理Prompt提示词工程)

任务 目标 核心技术
文本分类 判断句子属于哪个类别 Few-shot + System Prompt
信息抽取 从文本中提取结构化实体 Few-shot + Schema 约束 + JSON 解析
语义匹配 判断两个句子语义是否相似 Few-shot + 二元分类 Prompt

二、任务一：文本分类 

2.1 Prompt 设计

 
  1. system_prompt = "现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：{class_list}类别中。"
  2.  
  3. user_prompt = f"“{sentence}”是 {class_list} 里的什么类别？直接输出类别结果，不要给出解释等其他内容。"
 
python
 

2.2 Few-shot 示例

 
  1. class_examples = {
  2. "新闻报道": "今日，股市经历了一轮震荡...",
  3. "财务报告": "本公司年度财务报告显示...",
  4. "公司公告": "本公司高兴地宣布成功完成...",
  5. "分析师报告": "最新的行业分析报告指出...",
  6. }
 
python
 

2.3 关键技巧

技巧 作用
System Prompt 明确角色 让模型知道自己是“分类器”
限制输出格式 直接输出类别结果，不要给出解释
Few-shot 覆盖所有类别 每个类别给一个示例，避免类别偏见

2.4 效果示例

输入：

央行发布公告宣布降低利率，以刺激经济增长。

输出：

新闻报道

代码

 
  1. """
  2. 利用 LLM 进行文本分类任务。
  3. """
  4. # rich第三方库，用来美化终端输出结果
  5. # from pprint import pprint
  6. from rich import print # 格式化输出, 需要安装 pip install rich
  7. from rich.console import Console
  8. import ollama
  9. from langchain_openai import ChatOpenAI
  10. from config import Config
  11. import re
  12.  
  13. conf = Config()
  14.  
  15. llm = ChatOpenAI(
  16. model=conf.model_name,
  17. api_key=conf.api_key,
  18. base_url=conf.base_url,
  19. temperature=1.0, # 温度参数
  20. max_tokens=1024,
  21. max_retries=3,
  22. timeout=60,
  23. )
  24.  
  25. # 提供所有类别以及每个类别下的样例 few_shot example
  26. class_examples = {
  27. "新闻报道": "今日，股市经历了一轮震荡，受到宏观经济数据和全球贸易紧张局势的影响。投资者密切关注美联储可能的政策调整，以适应市场的不确定性。",
  28. "财务报告": "本公司年度财务报告显示，去年公司实现了稳步增长的盈利，同时资产负债表呈现强劲的状况。经济环境的稳定和管理层的有效战略执行为公司的健康发展奠定了基础。",
  29. "公司公告": "本公司高兴地宣布成功完成最新一轮并购交易，收购了一家在人工智能领域领先的公司。这一战略举措将有助于扩大我们的业务领域，提高市场竞争力",
  30. "分析师报告": "最新的行业分析报告指出，科技公司的创新将成为未来增长的主要推动力。云计算、人工智能和数字化转型被认为是引领行业发展的关键因素，投资者应关注这些趋势",
  31. }
  32.  
  33.  
  34. # 初始化prompt, 构造ollama需要的messages信息
  35. def init_prompts():
  36. """
  37. 初始化前置prompt，便于模型做 incontext learning。
  38. """
  39. # 获取class_examples字典中的所有key值保存到列表中 所有类别
  40. class_list = list(class_examples.keys())
  41. # print(f'class_list--->{class_list}')
  42. # system:系统角色 messages列表 [{}, {}, ...]
  43. pre_history = [
  44. {
  45. "role": "system",
  46. "content": f"现在你是一个文本分类器，你需要按照要求将我给你的句子分类到：{class_list}类别中。",
  47. }
  48. ]
  49.  
  50. # 构造历史记录，包含所有类别的样例
  51. # print(f'class_examples.items()--->{class_examples.items()}')
  52. for _type, exmpale in class_examples.items(): # [(文本分类, 文本内容), (文本分类, 文本内容), ...]
  53. # print(f'“{exmpale}”是 {class_list} 里的什么类别？')
  54. # print("content--->", _type)
  55.  
  56. # 在list中追加字典, user:用户角色
  57. pre_history.append(
  58. {"role": "user", "content": f"“{exmpale}”是 {class_list} 里的什么类别？"}
  59. )
  60. # assistant:模型角色
  61. pre_history.append({"role": "assistant", "content": _type})
  62.  
  63. return {"class_list": class_list, "pre_history": pre_history}
  64.  
  65.  
  66. # 模型推理
  67. def inference(sentences: list, custom_settings: dict):
  68. """
  69. 推理函数。
  70. Args:
  71. sentences (List[str]): 待推理的句子。
  72. custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
  73. """
  74. # print(f'sentences--->{sentences}')
  75. for sentence in sentences:
  76. # console.status(): 终端显示时创建一个高亮绿色的状态栏，用于显示模型推理的进度。
  77. with console.status("[bold bright_green] Model Inference..."):
  78. # sentence_with_prompt = f"“{sentence}”是 {custom_settings['class_list']} 里的什么类别？"
  79. sentence_with_prompt = f"“{sentence}”是 {custom_settings['class_list']} 里的什么类别？直接输出类别结果, 不要给出解释等其他内容。"
  80. # print(f'sentence_with_prompt--》{sentence_with_prompt}')
  81.  
  82. # 方式一: ollama api调用
  83. # *custom_settings['pre_history']: 列表拆包 eg:*[{},{},{},...]->{},{},{}...
  84. response = ollama.chat(
  85. model="qwen2:0.5b",
  86. messages=[
  87. *custom_settings["pre_history"],
  88. {"role": "user", "content": sentence_with_prompt},
  89. ],
  90. )
  91. # print(f'response--->{response}')
  92. # response = response["message"]["content"]
  93. response = response.message.content
  94. print(f'response--->{response}')
  95.  
  96. # # 方式二: api调用
  97. # response = llm.invoke(input=[
  98. # *custom_settings["pre_history"],
  99. # {"role": "user", "content": sentence_with_prompt},
  100. # ])
  101. # response = response.content
  102. # # print(f'response--->{response}')
  103. # response = re.sub(r"<think>.*?</think>", "", response, flags=re.DOTALL).strip()
  104. # # print(f'response--->{response}')
  105. #
  106. # print(f">>> [bold bright_red]sentence: {sentence}")
  107. # print(f">>> [bold bright_green]inference answer: {response}")
  108. # print("*" * 70)
  109.  
  110.  
  111. if __name__ == "__main__":
  112. # 实例化终端对象, 美化终端输出
  113. console = Console()
  114.  
  115. # 待推理的句子
  116. sentences = [
  117. "今日，央行发布公告宣布降低利率，以刺激经济增长。这一降息举措将影响贷款利率，并在未来几个季度内对金融市场产生影响。",
  118. "本公司宣布成功收购一家在创新科技领域领先的公司，这一战略性收购将有助于公司拓展技术能力和加速产品研发。",
  119. "公司资产负债表显示，公司偿债能力强劲，现金流充足，为未来投资和扩张提供了坚实的财务基础。",
  120. "最新的分析报告指出，可再生能源行业预计将在未来几年经历持续增长，投资者应该关注这一领域的投资机会",
  121. "PDD公司2025年财报显示, 公司预计亏损7000w到1个亿之间"
  122. ]
  123.  
  124. # 初始化prompt配置, 调用init_prompts函数, 返回prompt配置内容
  125. custom_settings = init_prompts()
  126. print('custom_settings--->', custom_settings)
  127.  
  128. # 模型推理
  129. inference(sentences, custom_settings)
 
python
 

三、任务二：信息抽取 

3.1 Schema 定义

 
  1. schema = {
  2. "金融": ["日期", "股票名称", "开盘价", "收盘价", "成交量"],
  3. "新闻": ["日期", "新闻标题", "新闻内容"],
  4. }
 
python
 

3.2 Prompt 模板

IE_PATTERN = "{}\n\n提取上述句子中{}的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来表示，多个值之间用','分隔。"
python
 

3.3 Few-shot 示例

 
  1. ie_examples = {
  2. "金融": [{
  3. "content": "2023-01-10，股票古哥-D美股开盘价100美元...",
  4. "answers": {
  5. "日期": ["2023-01-10"],
  6. "股票名称": ["古哥-D[EOOE]美股"],
  7. "开盘价": ["100美元"],
  8. "收盘价": ["102美元"],
  9. "成交量": ["520000"],
  10. },
  11. }],
  12. }
 
python
 

3.4 后处理容错

 
  1. def clean_response(response: str):
  2. # 1. 提取 Markdown 代码块中的 JSON
  3. if "```json" in response:
  4. res = re.findall(r"```json(.*?)```", response, re.DOTALL)
  5. if len(res) and res[0]:
  6. response = res[0]
  7.  
  8. # 2. 中文顿号 → 英文逗号
  9. response = response.replace("、", ",")
  10.  
  11. # 3. JSON 解析兜底
  12. try:
  13. return json.loads(response)
  14. except:
  15. return response
 
python
 

3.5 关键技巧

技巧 作用
Schema 约束 明确要抽取哪些字段
兜底处理 ['原文中未提及'] 处理缺失信息
正则提取 处理模型输出的 Markdown 包裹
标点替换 、 → , 避免 JSON 解析失败

3.6 效果示例

输入：

2023-02-15，股票佰笃[BD]美股开盘价10美元，收盘价13美元，成交量460,000

输出：

{"日期": ["2023-02-15"], "股票名称": ["佰笃[BD]美股"], "开盘价": ["10美元"], "收盘价": ["13美元"], "成交量": ["460,000"]}
python
 

代码

 
  1. import json
  2. import ollama
  3. import re # 使用正则表达式来匹配字符串
  4. from rich import print
  5.  
  6. # 定义不同类型下的实体类型
  7. schema = {
  8. "金融": ["日期", "股票名称", "开盘价", "收盘价", "成交量"],
  9. "新闻": ["日期", "新闻标题", "新闻内容"],
  10. }
  11.  
  12. # 定义信息抽取的prompt模板, 其中{}为占位符，会被替换为句子和实体类型
  13. # 字符串格式化输出
  14. IE_PATTERN = "{}\n\n提取上述句子中{}的实体，并按照JSON格式输出，上述句子中不存在的信息用['原文中未提及']来表示，多个值之间用','分隔。"
  15. # print(type(IE_PATTERN))
  16. # print('IE_PATTERN--->', IE_PATTERN)
  17.  
  18.  
  19. # 提供一些例子供模型参考 one-shot example
  20. ie_examples = {
  21. "金融": [
  22. {
  23. "content": "2023-01-10，股市震荡。股票古哥-D[EOOE]美股今日开盘价100美元，一度飙升至105美元，随后回落至98美元，最终以102美元收盘，成交量达到520000。",
  24. "answers": {
  25. "日期": ["2023-01-10"],
  26. "股票名称": ["古哥-D[EOOE]美股"],
  27. "开盘价": ["100美元"],
  28. "收盘价": ["102美元"],
  29. "成交量": ["520000"],
  30. },
  31. }
  32. ],
  33. "新闻": [
  34. {
  35. "content": "2025-01-10，央行发布公告宣布降低利率，以刺激经济增长。这一降息举措将影响贷款利率，并在未来几个季度内对金融市场产生影响。",
  36. "answers": {
  37. "日期": ["2025-01-10"],
  38. "新闻标题": ["央行发布公告宣布降低利率"],
  39. "新闻内容": [
  40. "这一降息举措将影响贷款利率，并在未来几个季度内对金融市场产生影响。"
  41. ],
  42. },
  43. }
  44. ],
  45. }
  46.  
  47.  
  48. def init_prompts():
  49. """
  50. 初始化前置prompt，便于模型做 incontext learning。
  51. """
  52. # 系统角色描述
  53. ie_pre_history = [
  54. {"role": "system", "content": "你是一个信息抽取助手。"},
  55. ]
  56. # 循环遍历不同类型例子 对应不同类型
  57. for _type, example_list in ie_examples.items(): # [(key, value), ()...]
  58. # print(f'_type-->{_type}')
  59. # print(f'example_list-->{example_list}')
  60. # 循环遍历不同类型例子中的每个例子
  61. for example in example_list:
  62. # print(f'example-->{example}')
  63. # 根据content key值获取字典中的value值 文本信息
  64. sentence = example["content"]
  65. # print(f'sentence--》{sentence}')
  66.  
  67. # schema[_type]->根据字典中的key值获取value值
  68. # 根据_type值获取该类型对应的实体类型, 用', '拼接成字符串
  69. properties_str = ", ".join(schema[_type])
  70. # print(f'properties_str--》{properties_str}')
  71.  
  72. # 格式化_type和_type对应的实体类型，用于后续的prompt构造
  73. schema_str_list = f"“{_type}”({properties_str})"
  74. # print(f'schema_str_list-->{schema_str_list}')
  75.  
  76. # 根据sentence和schema_str_list构造prompt
  77. sentence_with_prompt = IE_PATTERN.format(sentence, schema_str_list)
  78. # print(f'sentence_with_prompt-->{sentence_with_prompt}')
  79.  
  80. # 用户和模型对话，其中role为user，content为sentence_with_prompt
  81. ie_pre_history.append(
  82. {"role": "user", "content": f"{sentence_with_prompt}"}
  83. )
  84.  
  85. # 模型输出，其中role为assistant，content为example['answers']
  86. # json.dumps(): 将字典转换为json字符串，ensure_ascii=False表示输出的json字符串中，中文字符不会被转码为unicode编码，而是直接输出为中文字符。
  87. ie_pre_history.append(
  88. {
  89. "role": "assistant",
  90. "content": f"{json.dumps(example['answers'], ensure_ascii=False)}",
  91. }
  92. )
  93.  
  94. # ie_pre_history: ollama.chat(message=) message的参数值
  95. return {"ie_pre_history": ie_pre_history}
  96.  
  97.  
  98. def clean_response(response: str):
  99. """
  100. 后处理模型输出
  101. Args:
  102. response (str): _description_
  103. """
  104. # response1='```json["name":lucy]```abc```json["name":lucy]```'
  105. # print(f'response--->{response}')
  106.  
  107. if "```json" in response:
  108. # 正则表达式匹配所有分组，并返回一个列表
  109. # re.DOTALL: 匹配包括换行在内的任何字符，包括 '\n'，'\\n'
  110. res = re.findall(r"```json(.*?)```", response, re.DOTALL) # 返回列表
  111. # print(f'res--》{res}')
  112.  
  113. # res是正则返回的匹配列表,如果len(res)不为空代表列表内有东西且res[0]不为空说明不是空字符串，则返回res[0]
  114. if len(res) and res[0]:
  115. response = res[0]
  116. # 替换中文、为英文,处理中文顿号导致 JSON 解析失败的完美兜底方案
  117. response = response.replace("、", ",")
  118. # print(f'response--》{response}')
  119. try:
  120. # 将response转换为json格式
  121. return json.loads(response)
  122. except:
  123. # 如果转换失败，则返回response
  124. return response
  125.  
  126.  
  127. def inference(sentences: list[dict[str, str]],
  128. custom_settings: dict):
  129. """
  130. 推理函数
  131. Args:
  132. sentences (List[str]): 待抽取的句子。
  133. custom_settings (dict): 初始设定，包含人为给定的 one-shot/few-shot example。
  134. """
  135. for item in sentences: # [{}, {}, ...]
  136. # item -> {}
  137. # 获取文本内容
  138. sentence = item["text"]
  139. # 获取文本类型
  140. cls_res = item["cls"]
  141. # 判断文本类型是否在schema字典中
  142. if cls_res not in schema:
  143. print(
  144. f"The type model inferenced {cls_res} which is not in schema dict, exited."
  145. )
  146. continue
  147. # 根据cls_res获取该类型对应的实体类型, 用', '拼接成字符串
  148. properties_str = ", ".join(schema[cls_res])
  149. # print(f'properties_str-->{properties_str}')
  150.  
  151. # 格式化cls_res和cls_res对应的实体类型, 用于后续的prompt构造
  152. schema_str_list = f"“{cls_res}”({properties_str})"
  153. # print(f'schema_str_list--->{schema_str_list}')
  154.  
  155. # 根据sentence和schema_str_list构造prompt
  156. sentence_with_ie_prompt = IE_PATTERN.format(sentence, schema_str_list)
  157. # print(f'sentence_with_ie_prompt-->{sentence_with_ie_prompt}')
  158.  
  159. # 使用 Ollama 调用 Qwen2.5:7b 模型
  160. # 构造模型需要的messages信息
  161. # *custom_settings['ie_pre_history']: 列表拆包 eg:*[{},{},{},...]->{},{},{}...
  162. # messages = custom_settings["ie_pre_history"] + [{"role": "user", "content": sentence_with_ie_prompt}]
  163. # print(messages)
  164.  
  165. messages = [
  166. *custom_settings["ie_pre_history"],
  167. {"role": "user", "content": sentence_with_ie_prompt},
  168. ]
  169. # print(f'messages--->{messages}')
  170.  
  171. # 调用模型, 获取模型输出
  172. response = ollama.chat(model="qwen2:0.5b", messages=messages)
  173. res_content = response["message"]["content"]
  174. # print(type(res_content)) # json格式的字符串类型
  175. print(f'res_content-->{res_content}')
  176.  
  177. # 通过自定义函数clean_response清洗模型输出
  178. # ie_res = clean_response(res_content)
  179. # print(f"sentence: {sentence}")
  180. # print(f"inference answer: {ie_res}")
  181.  
  182.  
  183. if __name__ == "__main__":
  184. # 初始化句子和自定义设置
  185. sentences = [
  186. {
  187. "text": "2023-02-15，寓意吉祥的节日，股票佰笃[BD]美股开盘价10美元，虽然经历了波动，但最终以13美元收盘，成交量微幅增加至460,000，投资者情绪较为平稳。",
  188. "cls": "金融",
  189. },
  190. {
  191. "text": "2023-04-05，市场迎来轻松氛围，股票盘古(0021)开盘价23元，尽管经历了波动，但最终以26美元收盘，成交量缩小至310,000，投资者保持观望态度。",
  192. "cls": "金融",
  193. },
  194. {
  195. "text": "2025-01-10，央行发布公告宣布降低利率，以刺激经济增长。这一降息举措将影响贷款利率，并在未来几个季度内对金融市场产生影响。",
  196. "cls": "新闻",
  197. },
  198. ]
  199.  
  200. # 初始化自定义设置
  201. custom_settings = init_prompts()
  202. # print("custom_settings--->", custom_settings)
  203.  
  204. # 开始推理
  205. inference(sentences, custom_settings)
 
python
 

四、任务三：语义匹配

4.1 Prompt 设计

 
  1. system_prompt = "现在你需要帮助我完成文本匹配任务，当我给你两个句子时，你需要回答我这两句话语义是否相似。只需要回答是否相似，不要做多余的回答。"
  2.  
  3. user_prompt = f'句子一: {sentence1}\n句子二: {sentence2}\n上面两句话是相似的语义吗？'
 
python
 

4.2 Few-shot 示例

 
  1. examples = {
  2. "是": [
  3. ('公司ABC发布了季度财报，显示盈利增长。', '财报披露，公司ABC利润上升。'),
  4. ],
  5. "不是": [
  6. ('黄金价格下跌，投资者抛售。', '外汇市场交易额创下新高。'),
  7. ('央行降息，刺激经济增长。', '新能源技术的创新。')
  8. ]
  9. }
 
python
 

4.3 关键技巧

技巧 作用
正负样本均衡 同时提供“是”和“不是”的示例
限制输出 只回答是否相似，不要做多余的回答
结构化输入 句子一: ...\n句子二: ... 清晰分隔

4.4 效果示例

输入：

句子一: 股票市场今日大涨，投资者乐观。
句子二: 持续上涨的市场让投资者感到满意。

输出：

是

代码

 
  1. """
  2. 利用 LLM 进行文本匹配任务。
  3. """
  4. from rich import print
  5. from rich.console import Console
  6. import ollama
  7.  
  8.  
  9. # 提供相似，不相似的语义匹配例子 few-shot example
  10. examples = {
  11. '是': [
  12. ('公司ABC发布了季度财报，显示盈利增长。', '财报披露，公司ABC利润上升。'),
  13. ],
  14. '不是': [
  15. ('黄金价格下跌，投资者抛售。', '外汇市场交易额创下新高。'),
  16. ('央行降息，刺激经济增长。', '新能源技术的创新。')
  17. ]
  18. }
  19.  
  20.  
  21. def init_prompts():
  22. """
  23. 初始化前置prompt，便于模型做 incontext learning。
  24. """
  25. # 系统角色描述，构造prompt
  26. pre_history = [{"role": "system",
  27. "content": "现在你需要帮助我完成文本匹配任务，当我给你两个句子时，你需要回答我这两句话语义是否相似。只需要回答是否相似，不要做多余的回答。"}, ]
  28. # 循序遍历所有例子，构造前置prompt
  29. for key, sentence_pairs in examples.items():
  30. # print(f'key-->{key}')
  31. # print(f'sentence_pairs-->{sentence_pairs}')
  32.  
  33. # 训练遍历每个例子的句子对
  34. for sentence_pair in sentence_pairs:
  35. # print(f'sentence_pair-->{sentence_pair}')
  36. # 获取每个例子中的句子对 元组拆包
  37. sentence1, sentence2 = sentence_pair
  38. # 用户角色描述，构造prompt
  39. pre_history.append(
  40. {"role": "user", "content": f'句子一: {sentence1}\n句子二: {sentence2}\n上面两句话是相似的语义吗？'})
  41. # 模型角色描述，构造prompt
  42. pre_history.append({"role": "assistant", "content": key})
  43.  
  44. return {'pre_history': pre_history}
  45.  
  46.  
  47. def inference(
  48. sentence_pairs: list,
  49. custom_settings: dict
  50. ):
  51. """
  52. 推理函数
  53. Args:
  54. sentence_pairs (List[str]): 待推理的句子对。
  55. custom_settings (dict): 初始设定，包含人为给定的 few-shot example。
  56. """
  57. # print('*' * 60)
  58. for sentence_pair in sentence_pairs:
  59. # print(f'sentence_pair-->{sentence_pair}')
  60. with console.status("[bold bright_green] Model Inference..."):
  61. sentence1, sentence2 = sentence_pair
  62. sentence_with_prompt = f'句子一: {sentence1}\n句子二: {sentence2}\n上面两句话是相似的语义吗？'
  63. # 调用模型
  64. response = ollama.chat(model="qwen2:0.5b",
  65. messages=[*custom_settings["pre_history"],
  66. {"role": 'user', "content": sentence_with_prompt}])
  67. # 获取模型输出
  68. response = response["message"]["content"]
  69. print(f'>>> [bold bright_red]sentence_pair:{sentence_pair}')
  70. print(f'>>> [bold bright_green]inference answer:{response}')
  71.  
  72.  
  73. if __name__ == '__main__':
  74. console = Console()
  75.  
  76. # 推理数据
  77. sentence_pairs = [
  78. ('股票市场今日大涨，投资者乐观。', '持续上涨的市场让投资者感到满意。'),
  79. ('油价大幅下跌，能源公司面临挑战。', '未来智能城市的建设趋势愈发明显。'),
  80. ('利率上升，影响房地产市场。', '高利率对房地产有一定冲击。'),
  81. ]
  82.  
  83. # 初始化prompt
  84. custom_settings = init_prompts()
  85. print(f'custom_settings-->{custom_settings}')
  86.  
  87. # 模型推理
  88. inference(
  89. sentence_pairs,
  90. custom_settings
  91. )
 
python
 

五、三个任务的通用经验

经验 说明
System Prompt 定角色 让模型明确自己的任务身份
Few-shot 是核心 1-3 个示例比长篇指令更有效
限制输出格式 减少模型“废话”，便于解析
后处理容错 正则提取 + 标点替换 + try-catch
小模型能力有限 0.5B 能跑，但 1.5B/7B 更稳定

六、一句话心得

Prompt 不是写作文，而是写“约束”。Few-shot 是给模型看标准答案，后处理是给模型兜底。三者配合，小模型也能做出稳定的效果。

希望这篇总结对你有帮助！你的代码结构清晰、容错完善，已经是一个很成熟的 Prompt 工程实践了。

posted @ 2026-05-06 14:33  charyGao  阅读(42)  评论(0)    收藏  举报