Prompt Engineering 提示工程
一、什么是提示工程（Prompt Engineering）
Prompt 就是发给大模型的指令，比如讲个笑话、用 Python 编个贪吃蛇游戏等；大模型只接受一种输入，那就是 prompt。本质上，所有大模型相关的工程工作，都是围绕 prompt 展开的；提示工程门槛低，天花板高。高质量prompt的核心要点：具体、丰富、少歧义。
1.1、prompt的典型构成
角色：给AI定义一个最匹配任务角色，比如：你是一位数学老师，你是一名软件工程师等
指示：对任务进行描述
上下文：给出与任务相关的其它背景信息
例子：必要时给出举例
输入：任务的输入信息
输出：输出的格式描述
1.2、对话系统的基本模块和思路
1、把输入的自然语音对话，转成结构化的信息NLU
2、用传统软件手段处理结构化信息，得到处理策略
3、把策略转成自然语言输出NLG
对话流程举例：
改变习惯，优先用prompt解决问题，用好prompt可以减轻后续处理的工作量和复杂度。
重点：我们发给大模型的prompt，不会改变大模型的权重
1.3、用prompt实现逐步调优
# 导入依赖库
from openai import OpenAI
# 初始化 OpenAI 客户端
client = OpenAI(api_key="sk-...",base_url='https:....')# 默认使用环境变量中的 OPENAI_API_KEY 和 OPENAI_BASE_URL
def get_completion(prompt, response_format="text", model="gpt-3.5-turbo"):
messages = [{"role": "user", "content": prompt}] # 将 prompt 作为用户输入
response = client.chat.completions.create(
model=model,
messages=messages,
temperature=0, # 模型输出的随机性，0 表示随机性最小
response_format={"type": response_format}, # 返回消息的格式，text 或 json_object
)
return response.choices[0].message.content # 返回模型生成的文本
# 任务描述
instruction = """
你的任务是识别用户对手机流量套餐产品的选择条件。
每种流量套餐产品包含三个属性：名称，月费价格，月流量。
根据用户输入，识别用户在上述三种属性上的需求是什么。
"""
# 用户输入
input_text = """
办个100G的套餐。
"""
# prompt 模版。instruction 和 input_text 会被替换为上面的内容
prompt = f"""
{instruction}
用户输入：
{input_text}
"""
# 调用大模型
response = get_completion(prompt)
print(response)
# 输出格式
output_format = """
以 JSON 格式输出
"""
# 稍微调整下咒语，加入输出格式
prompt = f"""
{instruction}
{output_format}
用户输入：
{input_text}
"""
# 调用大模型
response = get_completion(prompt, response_format="json_object")
print(response)
1.实现一个NLU
# 任务描述
instruction = """
你的任务是识别用户对手机流量套餐产品的选择条件。
每种流量套餐产品包含三个属性：名称，月费价格，月流量。
根据用户输入，识别用户在上述三种属性上的需求是什么。
"""
# 用户输入
input_text = """
办个100G的套餐。
"""
# prompt 模版。instruction 和 input_text 会被替换为上面的内容
prompt = f"""
{instruction}
用户输入：
{input_text}
"""
# 调用大模型
response = get_completion(prompt)
print(response)
2.约定输出格式
# 任务描述增加了字段的英文标识符
instruction = """
你的任务是识别用户对手机流量套餐产品的选择条件。
每种流量套餐产品包含三个属性：名称(name)，月费价格(price)，月流量(data)。
根据用户输入，识别用户在上述三种属性上的需求是什么。
"""
# 输出格式增加了各种定义、约束
output_format = """
以JSON格式输出。
1. name字段的取值为string类型，取值必须为以下之一：经济套餐、畅游套餐、无限套餐、校园套餐 或 null；
2. price字段的取值为一个结构体 或 null，包含两个字段：
(1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
(2) value, int类型
3. data字段的取值为取值为一个结构体 或 null，包含两个字段：
(1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
(2) value, int类型或string类型，string类型只能是'无上限'
4. 用户的意图可以包含按price或data排序，以sort字段标识，取值为一个结构体：
(1) 结构体中以"ordering"="descend"表示按降序排序，以"value"字段存储待排序的字段
(2) 结构体中以"ordering"="ascend"表示按升序排序，以"value"字段存储待排序的字段
输出中只包含用户提及的字段，不要猜测任何用户未直接提及的字段，不输出值为null的字段。
"""
input_text = "办个100G以上的套餐"
# input_text = "有没有便宜的套餐"
prompt = f"""
{instruction}
{output_format}
用户输入：
{input_text}
"""
response = get_completion(
prompt, response_format="json_object")
print(response)
3.把输出格式定义更精细
examples = """
便宜的套餐：{"sort":{"ordering"="ascend","value"="price"}}
有没有不限流量的：{"data":{"operator":"==","value":"无上限"}}
流量大的：{"sort":{"ordering"="descend","value"="data"}}
100G以上流量的套餐最便宜的是哪个：{"sort":{"ordering"="ascend","value"="price"},"data":{"operator":">=","value":100}}
月费不超过200的：{"price":{"operator":"<=","value":200}}
就要月费180那个套餐：{"price":{"operator":"==","value":180}}
经济套餐：{"name":"经济套餐"}
土豪套餐：{"name":"无限套餐"}
"""
input_text = "有没有土豪套餐"
# input_text = "办个200G的套餐"
# input_text = "有没有流量大的套餐"
# input_text = "200元以下，流量大的套餐有啥"
# input_text = "你说那个10G的套餐，叫啥名字"
# 有了例子
prompt = f"""
{instruction}
{output_format}
例如：
{examples}
用户输入：
{input_text}
"""
response = get_completion(prompt, response_format="json_object")
print(response)
4.加入例子
例子可以让输出更稳定：答错的，一定给例子；答对了，也给例子，能更稳定。
instruction = """
你的任务是识别用户对手机流量套餐产品的选择条件。
每种流量套餐产品包含三个属性：名称(name)，月费价格(price)，月流量(data)。
根据对话上下文，识别用户在上述三种属性上的需求是什么。识别结果要包含整个对话的信息。
"""
# 输出描述
output_format = """
以JSON格式输出。
1. name字段的取值为string类型，取值必须为以下之一：经济套餐、畅游套餐、无限套餐、校园套餐 或 null；
2. price字段的取值为一个结构体 或 null，包含两个字段：
(1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
(2) value, int类型
3. data字段的取值为取值为一个结构体 或 null，包含两个字段：
(1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
(2) value, int类型或string类型，string类型只能是'无上限'
4. 用户的意图可以包含按price或data排序，以sort字段标识，取值为一个结构体：
(1) 结构体中以"ordering"="descend"表示按降序排序，以"value"字段存储待排序的字段
(2) 结构体中以"ordering"="ascend"表示按升序排序，以"value"字段存储待排序的字段
输出中只包含用户提及的字段，不要猜测任何用户未直接提及的字段。不要输出值为null的字段。
"""
# 多轮对话的例子
examples = """
客服：有什么可以帮您
用户：100G套餐有什么
{"data":{"operator":">=","value":100}}
客服：有什么可以帮您
用户：100G套餐有什么
客服：我们现在有无限套餐，不限流量，月费300元
用户：太贵了，有200元以内的不
{"data":{"operator":">=","value":100},"price":{"operator":"<=","value":200}}
客服：有什么可以帮您
用户：便宜的套餐有什么
客服：我们现在有经济套餐，每月50元，10G流量
用户：100G以上的有什么
{"data":{"operator":">=","value":100},"sort":{"ordering"="ascend","value"="price"}}
客服：有什么可以帮您
用户：100G以上的套餐有什么
客服：我们现在有畅游套餐，流量100G，月费180元
用户：流量最多的呢
{"sort":{"ordering"="descend","value"="data"},"data":{"operator":">=","value":100}}
"""
input_text = "哪个便宜"
# input_text = "无限量哪个多少钱"
# input_text = "流量最大的多少钱"
# 多轮对话上下文
context = f"""
客服：有什么可以帮您
用户：有什么100G以上的套餐推荐
客服：我们有畅游套餐和无限套餐，您有什么价格倾向吗
用户：{input_text}
"""
prompt = f"""
{instruction}
{output_format}
{examples}
{context}
"""
response = get_completion(prompt, response_format="json_object")
print(response)
5.实现对话策略和NLG
import json
import copy
from openai import OpenAI
instruction = """
你的任务是识别用户对手机流量套餐产品的选择条件。
每种流量套餐产品包含三个属性：名称(name)，月费价格(price)，月流量(data)。
根据用户输入，识别用户在上述三种属性上的需求是什么。
"""
# 输出格式
output_format = """
以JSON格式输出。
1. name字段的取值为string类型，取值必须为以下之一：经济套餐、畅游套餐、无限套餐、校园套餐 或 null；
2. price字段的取值为一个结构体 或 null，包含两个字段：
(1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
(2) value, int类型
3. data字段的取值为取值为一个结构体 或 null，包含两个字段：
(1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
(2) value, int类型或string类型，string类型只能是'无上限'
4. 用户的意图可以包含按price或data排序，以sort字段标识，取值为一个结构体：
(1) 结构体中以"ordering"="descend"表示按降序排序，以"value"字段存储待排序的字段
(2) 结构体中以"ordering"="ascend"表示按升序排序，以"value"字段存储待排序的字段
输出中只包含用户提及的字段，不要猜测任何用户未直接提及的字段。
DO NOT OUTPUT NULL-VALUED FIELD! 确保输出能被json.loads加载。
"""
examples = """
便宜的套餐：{"sort":{"ordering"="ascend","value"="price"}}
有没有不限流量的：{"data":{"operator":"==","value":"无上限"}}
流量大的：{"sort":{"ordering"="descend","value"="data"}}
100G以上流量的套餐最便宜的是哪个：{"sort":{"ordering"="ascend","value"="price"},"data":{"operator":">=","value":100}}
月费不超过200的：{"price":{"operator":"<=","value":200}}
就要月费180那个套餐：{"price":{"operator":"==","value":180}}
经济套餐：{"name":"经济套餐"}
土豪套餐：{"name":"无限套餐"}
"""
class NLU:
def __init__(self):
self.prompt_template = f"""
{instruction}\n\n{output_format}\n\n{examples}\n\n用户输入：\n__INPUT__"""
def _get_completion(self, prompt, model="gpt-3.5-turbo"):
messages = [{"role": "user", "content": prompt}]
response = client.chat.completions.create(
model=model,
messages=messages,
temperature=0, # 模型输出的随机性，0 表示随机性最小
response_format={"type": "json_object"},
)
semantics = json.loads(response.choices[0].message.content)
return {k: v for k, v in semantics.items() if v}
def parse(self, user_input):
prompt = self.prompt_template.replace("__INPUT__", user_input)
return self._get_completion(prompt)
class DST:
def __init__(self):
pass
def update(self, state, nlu_semantics):
if "name" in nlu_semantics:
state.clear()
if "sort" in nlu_semantics:
slot = nlu_semantics["sort"]["value"]
if slot in state and state[slot]["operator"] == "==":
del state[slot]
for k, v in nlu_semantics.items():
state[k] = v
return state
class MockedDB:
def __init__(self):
self.data = [
{"name": "经济套餐", "price": 50, "data": 10, "requirement": None},
{"name": "畅游套餐", "price": 180, "data": 100, "requirement": None},
{"name": "无限套餐", "price": 300, "data": 1000, "requirement": None},
{"name": "校园套餐", "price": 150, "data": 200, "requirement": "在校生"},
]
def retrieve(self, **kwargs):
records = []
for r in self.data:
select = True
if r["requirement"]:
if "status" not in kwargs or kwargs["status"] != r["requirement"]:
continue
for k, v in kwargs.items():
if k == "sort":
continue
if k == "data" and v["value"] == "无上限":
if r[k] != 1000:
select = False
break
if "operator" in v:
if not eval(str(r[k])+v["operator"]+str(v["value"])):
select = False
break
elif str(r[k]) != str(v):
select = False
break
if select:
records.append(r)
if len(records) <= 1:
return records
key = "price"
reverse = False
if "sort" in kwargs:
key = kwargs["sort"]["value"]
reverse = kwargs["sort"]["ordering"] == "descend"
return sorted(records, key=lambda x: x[key], reverse=reverse)
class DialogManager:
def __init__(self, prompt_templates):
self.state = {}
self.session = [
{
"role": "system",
"content": "你是一个手机流量套餐的客服代表，你叫小智。可以帮助用户选择最合适的流量套餐产品。"
}
]
self.nlu = NLU()
self.dst = DST()
self.db = MockedDB()
self.prompt_templates = prompt_templates
def _wrap(self, user_input, records):
if records:
prompt = self.prompt_templates["recommand"].replace(
"__INPUT__", user_input)
r = records[0]
for k, v in r.items():
prompt = prompt.replace(f"__{k.upper()}__", str(v))
else:
prompt = self.prompt_templates["not_found"].replace(
"__INPUT__", user_input)
for k, v in self.state.items():
if "operator" in v:
prompt = prompt.replace(
f"__{k.upper()}__", v["operator"]+str(v["value"]))
else:
prompt = prompt.replace(f"__{k.upper()}__", str(v))
return prompt
def _call_chatgpt(self, prompt, model="gpt-3.5-turbo"):
session = copy.deepcopy(self.session)
session.append({"role": "user", "content": prompt})
response = client.chat.completions.create(
model=model,
messages=session,
temperature=0,
)
return response.choices[0].message.content
def run(self, user_input):
# 调用NLU获得语义解析
semantics = self.nlu.parse(user_input)
print("===semantics===")
print(semantics)
# 调用DST更新多轮状态
self.state = self.dst.update(self.state, semantics)
print("===state===")
print(self.state)
# 根据状态检索DB，获得满足条件的候选
records = self.db.retrieve(**self.state)
# 拼装prompt调用chatgpt
prompt_for_chatgpt = self._wrap(user_input, records)
print("===gpt-prompt===")
print(prompt_for_chatgpt)
# 调用chatgpt获得回复
response = self._call_chatgpt(prompt_for_chatgpt)
# 将当前用户输入和系统回复维护入chatgpt的session
self.session.append({"role": "user", "content": user_input})
self.session.append({"role": "assistant", "content": response})
return response
加入垂直知识：加入指定情况夏的回答模板，话术更专业。
prompt_templates = {
"recommand": "用户说：__INPUT__ \n\n向用户介绍如下产品：__NAME__，月费__PRICE__元，每月流量__DATA__G。",
"not_found": "用户说：__INPUT__ \n\n没有找到满足__PRICE__元价位__DATA__G流量的产品，询问用户是否有其他选择倾向。"
}
dm = DialogManager(prompt_templates)
# 两轮对话
print("# Round 1")
response = dm.run("300太贵了，200元以内有吗")
print("===response===")
print(response)
print("# Round 2")
response = dm.run("流量大的")
print("===response===")
print(response)
增加约束：改变语气、口吻等风格
# 定义语气要求。"NO COMMENTS. NO ACKNOWLEDGEMENTS."是常用 prompt，表示「有事儿说事儿，别 bb」
ext = "很口语，亲切一些。不用说“抱歉”。直接给出回答，不用在前面加“小瓜说：”。NO COMMENTS. NO ACKNOWLEDGEMENTS."
prompt_templates = {k: v+ext for k, v in prompt_templates.items()}
dm = DialogManager(prompt_templates)
response = dm.run("300太贵了，200元以内有吗")
response = dm.run("流量大的")
print("===response===")
print(response)
实现统一口径，用例子实现。
ext = "\n\n遇到类似问题，请参照以下回答：\n问：流量包太贵了\n答：亲，我们都是全省统一价哦。"
prompt_templates = {k: v+ext for k, v in prompt_templates.items()}
dm = DialogManager(prompt_templates)
response = dm.run("这流量包太贵了")
print("===response===")
print(response)
6.纯api实现
import json
from openai import OpenAI
def print_json(data):
"""
打印参数。如果参数是有结构的（如字典或列表），则以格式化的 JSON 形式打印；
否则，直接打印该值。
"""
if hasattr(data, 'model_dump_json'):
data = json.loads(data.model_dump_json())
if (isinstance(data, (list, dict))):
print(json.dumps(
data,
indent=4,
ensure_ascii=False
))
else:
print(data)
# 定义消息历史。先加入 system 消息，里面放入对话内容以外的 prompt
messages = [
{
"role": "system",
"content": """
你是一个手机流量套餐的客服代表，你叫小瓜。可以帮助用户选择最合适的流量套餐产品。可以选择的套餐包括：
经济套餐，月费50元，10G流量；
畅游套餐，月费180元，100G流量；
无限套餐，月费300元，1000G流量；
校园套餐，月费150元，200G流量，仅限在校生。
"""
}
]
def get_completion(prompt, model="gpt-3.5-turbo"):
# 把用户输入加入消息历史
messages.append({"role": "user", "content": prompt})
response = client.chat.completions.create(
model=model,
messages=messages,
temperature=0.7,
)
msg = response.choices[0].message.content
# 把模型生成的回复加入消息历史。很重要，否则下次调用模型时，模型不知道上下文
messages.append({"role": "assistant", "content": msg})
return msg
get_completion("流量最大的套餐是什么？")
get_completion("多少钱？")
get_completion("给我办一个")
print_json(messages)
1.4、进阶技巧
（1）思维链
1.让 AI 生成更多相关的内容，构成更丰富的上文，从而提升下文正确的概率
2.对涉及计算和逻辑推理等复杂问题，尤为有效
方法：提示词中加入如：请一步一步分析以下对话；请仔细一步步想想等。
（2）自洽性
一种对抗幻觉的手段。就像我们做数学题，要多次验算一样。
同样 prompt 跑多次，通过投票选出最终结果。
from openai import OpenAI
def get_completion(prompt, model="gpt-3.5-turbo"):
messages = [{"role": "user", "content": prompt}]
response = client.chat.completions.create(
model=model,
messages=messages,
temperature=0.9, # 必须加大随机性
)
return response.choices[0].message.content
instruction = """
给定一段用户与手机流量套餐客服的对话，。
你的任务是判断客服介绍产品信息的准确性：
当向用户介绍流量套餐产品时，客服人员必须准确提及产品名称、月费价格和月流量总量。上述信息缺失一项或多项，或信息与实时不符，都算信息不准确
已知产品包括：
经济套餐：月费50元，月流量10G
畅游套餐：月费180元，月流量100G
无限套餐：月费300元，月流量1000G
校园套餐：月费150元，月流量200G，限在校学生办理
"""
# 输出描述
output_format = """
如果信息准确，输出：Y
如果信息不准确，输出：N
"""
context = """
用户：你们有什么流量大的套餐
客服：您好，我们现在正在推广无限套餐，每月300元就可以享受1000G流量，您感兴趣吗
"""
cot = "请一步一步分析以下对话"
prompt = f"""
{instruction}
{output_format}
{cot}
对话记录：
{context}
"""
# 连续调用 5 次
for _ in range(5):
print(f"------第{_+1}次------")
response = get_completion(prompt)
print(response)
二、提示工程经验总结
1、别急着上代码，先尝试用 prompt 解决；
2、别迷信 prompt，合理组合传统方法提升确定性，减少幻觉；
3、定义角色、给例子是最常用的技巧；
4、必要时上思维链，结果更准确；
5、防御 prompt 攻击非常重要，但很难。
三、OpenAI API 的几个重要参数
def get_chat_completion(session, user_prompt, model="gpt-3.5-turbo"):
session.append({"role": "user", "content": user_prompt})
response = client.chat.completions.create(
model=model,
messages=session,
# 以下默认值都是官方默认值
temperature=1, # 生成结果的多样性。取值 0~2 之间，越大越发散，越小越收敛
seed=None, # 随机数种子。指定具体值后，temperature 为 0 时，每次生成的结果都一样
stream=False, # 数据流模式，一个字一个字地接收
response_format={"type": "text"}, # 返回结果的格式，json_object 或 text
top_p=1, # 随机采样时，只考虑概率前百分之多少的 token。不建议和 temperature 一起使用
n=1, # 一次返回 n 条结果
max_tokens=100, # 每条结果最多几个 token（超过截断）
presence_penalty=0, # 对出现过的 token 的概率进行降权
frequency_penalty=0, # 对出现过的 token 根据其出现过的频次，对其的概率进行降权
logit_bias={}, # 对指定 token 的采样概率手工加/降权，不常用
)
msg = response.choices[0].message.content
return msg
原文地址：https://blog.csdn.net/u012121721/article/details/143632444
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！