💡 这节课会带给你

  1. 了解提示工程的跨时代意义，改「精确逻辑」习惯为「模糊执行」习惯
  2. 掌握提示工程的核心方法论，比 99% 的人达成更好效果
  3. 掌握提示调优的基本方法，了解它在实际生产中的应用
  4. 掌握防止Prompt注入的方法，AI更安全

开始上课！

1.什么是提示工程（Prompt Engineering）

提示工程也叫「指令工程」。

  • Prompt 就是你发给 ChatGPT 的指令，比如「讲个笑话」、「用 Python 编个贪吃蛇游戏」、「给男/女朋友写封情书」等
  • 貌似简单，但意义非凡
    • Prompt 是 AGI 时代的「编程语言」
    • Prompt 工程是 AGI 时代的「软件工程」
    • 提示工程师是 AGI 时代的「程序员」
  • 学会提示工程，就像学用鼠标、键盘一样，是 AGI 时代的基本技能
  • 专门的「提示工程师」不会长久，因为每个人都要会「提示工程」

思考：

如果人人都会，那我们的优势是什么？

1.1、我们在「提示工程」上的优势

我们懂「大模型只会基于概率生成下一个字」这个原理，所以知道：

  • 为什么有的指令有效，有的指令无效
  • 为什么同样的指令有时有效，有时无效
  • 怎么提升指令有效的概率

我们懂编程：

  • 知道哪些问题用提示工程解决更高效，哪些用传统编程更高效
  • 能完成和业务系统的对接，把效能发挥到极致

1.2、使用 Prompt 的两种目的

  1. 获得具体问题的具体结果，比如「我该学 Vue 还是 React？」「PHP 为什么是最好的语言？」
  2. 固化一套 Prompt 到程序中，成为系统功能的一部分，比如「每天生成本公司的简报」「AI 客服系统」「基于公司知识库的问答」

前者主要通过 ChatGPT、ChatALL 这样的界面操作。后者就要动代码了。我们会专注于后者，因为：

  1. 后者更难，掌握后能轻松搞定前者
  2. 后者是我们的独特优势

1.3、Prompt 调优

找到好的 prompt 是个持续迭代的过程，需要不断调优。

  • 从人的视角：说清楚自己到底想要什么
  • 从机器的视角：不是每个细节它都能猜到你的想法，它猜不到的，你需要详细说
  • 从模型的视角：不是每种说法它都能完美理解，需要尝试和技巧

二、Prompt 的构成

  • 指示: 对任务进行描述
  • 上下文: 给出与任务相关的其它背景信息（尤其在多轮交互中）
  • 例子: 必要时给出举例，学术中称为 one-shot learning, few-shot learning 或 in-context learning；实践证明其对输出正确性有帮助
  • 输入: 任务的输入信息；在提示词中明确的标识出输入
  • 输出: 输出的格式描述，以便后继模块自动解析模型的输出结果，比如（JSON、XML）

2.1、设定一个业务场景来讲解上述知识

业务场景：办理流量包的智能客服

流量包产品：

名称 流量（G/月） 价格（元/月） 适用人群
经济套餐 10 50 无限制
畅游套餐 100 180 无限制
无限套餐 1000 300 无限制
校园套餐 200 150 在校生

2.2、对话系统的基本模块（简介）

2.prompt - 图1

对话流程举例： 2.prompt - 图2

2.3、用Prompt实现上述模块功能

环境搭建

调试 prompt 的过程其实在图形界面里开始会更方便，但为了方便演示和大家上手体验，我们直接在代码里调试。

  1. # 加载环境变量
  2. import openai
  3. import os
  5. from dotenv import load_dotenv, find_dotenv
  6. _ = load_dotenv(find_dotenv())  # 读取本地 .env 文件，里面定义了 OPENAI_API_KEY
  8. openai.api_key = os.getenv('OPENAI_API_KEY')
  1. # 基于 prompt 生成文本
  2. def get_completion(prompt, model="gpt-3.5-turbo"):
  3.     messages = [{"role": "user", "content": prompt}]
  4.     response = openai.ChatCompletion.create(
  5.         model=model,
  6.         messages=messages,
  7.         temperature=0,  # 模型输出的随机性，0 表示随机性最小
  8.     )
  9.     return response.choices[0].message["content"]

2.3.1、实现一个NLU

任务描述+输入

  1. # 任务描述
  2. instruction = """
  3. 你的任务是识别用户对手机流量套餐产品的选择条件。
  4. 每种流量套餐产品包含三个属性：名称，月费价格，月流量。
  5. 根据用户输入，识别用户在上述三种属性上的倾向。
  6. """
  8. # 用户输入
  9. input_text = """
  10. 办个100G的套餐。
  11. """
  13. # 这是系统预置的 prompt。魔法咒语的秘密都在这里
  14. prompt = f"""
  15. {instruction}
  17. # 用户输入：
  18. {input_text}
  19. """
  21. response = get_completion(prompt)
  22. print(response)

用户在流量套餐产品的选择条件上的倾向为：

  • 名称：用户倾向选择100G的套餐。
  • 月费价格：用户未提及对月费价格的倾向。
  • 月流量：用户倾向选择100G的套餐。

约定输出格式

  1. # 输出描述
  2. output_format = """
  3. 以JSON格式输出
  4. """
  6. # 稍微调整下咒语
  7. prompt = f"""
  8. {instruction}
  10. {output_format}
  12. 用户输入：
  13. {input_text}
  14. """
  16. response = get_completion(prompt)
  17. print(response)

{
“名称”: “100G套餐”,
“月费价格”: “未知”,
“月流量”: “100G”
}

把描述定义的更精细

  1. instruction = """
  2. 你的任务是识别用户对手机流量套餐产品的选择条件。
  3. 每种流量套餐产品包含三个属性：名称(name)，月费价格(price)，月流量(data)。
  4. 根据用户输入，识别用户在上述三种属性上的倾向。
  5. """
  7. # 输出描述
  8. output_format = """
  9. 以JSON格式输出。
  10. 1. name字段的取值为string类型，取值必须为以下之一：经济套餐、畅游套餐、无限套餐、校园套餐 或 null；
  12. 2. price字段的取值为一个结构体 或 null，包含两个字段：
  13. (1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
  14. (2) value, int类型
  16. 3. data字段的取值为取值为一个结构体 或 null，包含两个字段：
  17. (1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
  18. (2) value, int类型或string类型，string类型只能是'无上限'
  20. 4. 用户的意图可以包含按price或data排序，以sort字段标识，取值为一个结构体：
  21. (1) 结构体中以"ordering"="descend"表示按降序排序，以"value"字段存储待排序的字段
  22. (2) 结构体中以"ordering"="ascend"表示按升序排序，以"value"字段存储待排序的字段
  24. 只输出中只包含用户提及的字段，不要猜测任何用户未直接提及的字段，不输出值为null的字段。
  25. """
  27. #input_text = "办个100G以上的套餐"
  28. #input_text = "我要无限量套餐"
  29. input_text = "有没有便宜的套餐"
  31. prompt = f"""
  32. {instruction}
  34. {output_format}
  36. 用户输入：
  37. {input_text}
  38. """
  40. response = get_completion(prompt)
  41. print(response)

{
“name”: “经济套餐”
}

加入例子：让输出更稳定

  1. examples = """
  2. 便宜的套餐：{"sort":{"ordering"="ascend","value"="price"}}
  3. 有没有不限流量的：{"data":{"operator":"==","value":"无上限"}}
  4. 流量大的：{"sort":{"ordering"="descend","value"="data"}}
  5. 100G以上流量的套餐最便宜的是哪个：{"sort":{"ordering"="ascend","value"="price"},"data":{"operator":">=","value":100}}
  6. 月费不超过200的：{"price":{"operator":"<=","value":200}}
  7. 就要月费180那个套餐：{"price":{"operator":"==","value":180}}
  8. 经济套餐：{"name":"经济套餐"}
  9. """
  11. #input_text = "办个200G的套餐"
  12. input_text = "有没有流量大的套餐"
  13. #input_text = "200元以下，流量大的套餐有啥"
  14. #input_text = "你说那个10G的套餐，叫啥名字"
  16. prompt = f"""
  17. {instruction}
  19. {output_format}
  21. 例如：
  22. {examples}
  24. 用户输入：
  25. {input_text}
  27. """
  29. response = get_completion(prompt)
  30. print(response)

{“sort”:{“ordering”:”descend”,”value”:”data”}}

改变习惯，优先用 Prompt 解决问题

用好prompt可以减轻预处理和后处理的工作量和复杂度。

划重点：一切问题先尝试用 prompt 解决，往往有四两拨千斤的效果

2.3.2、实现上下文DST

在Prompt中加入上下文

  1. instruction = """
  2. 你的任务是识别用户对手机流量套餐产品的选择条件。
  3. 每种流量套餐产品包含三个属性：名称(name)，月费价格(price)，月流量(data)。
  4. 根据对话上下文，识别用户在上述属性上的倾向。识别结果要包含整个对话的信息。
  5. """
  7. # 输出描述
  8. output_format = """
  9. 以JSON格式输出。
  10. 1. name字段的取值为string类型，取值必须为以下之一：经济套餐、畅游套餐、无限套餐、校园套餐 或 null；
  12. 2. price字段的取值为一个结构体 或 null，包含两个字段：
  13. (1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
  14. (2) value, int类型
  16. 3. data字段的取值为取值为一个结构体 或 null，包含两个字段：
  17. (1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
  18. (2) value, int类型或string类型，string类型只能是'无上限'
  20. 4. 用户的意图可以包含按price或data排序，以sort字段标识，取值为一个结构体：
  21. (1) 结构体中以"ordering"="descend"表示按降序排序，以"value"字段存储待排序的字段
  22. (2) 结构体中以"ordering"="ascend"表示按升序排序，以"value"字段存储待排序的字段
  24. 只输出中只包含用户提及的字段，不要猜测任何用户未直接提及的字段。不要输出值为null的字段。
  25. """
  26. #DO NOT OUTPUT NULL-VALUED FIELD!
  28. examples = """
  29. 客服：有什么可以帮您
  30. 用户：100G套餐有什么
  32. {"data":{"operator":">=","value":100}}
  34. 客服：有什么可以帮您
  35. 用户：100G套餐有什么
  36. 客服：我们现在有无限套餐，不限流量，月费300元
  37. 用户：太贵了，有200元以内的不
  39. {"data":{"operator":">=","value":100},"price":{"operator":"<=","value":200}}
  41. 客服：有什么可以帮您
  42. 用户：便宜的套餐有什么
  43. 客服：我们现在有经济套餐，每月50元，10G流量
  44. 用户：100G以上的有什么
  46. {"data":{"operator":">=","value":100},"sort":{"ordering"="ascend","value"="price"}}
  48. 客服：有什么可以帮您
  49. 用户：100G以上的套餐有什么
  50. 客服：我们现在有畅游套餐，流量100G，月费180元
  51. 用户：流量最多的呢
  53. {"sort":{"ordering"="descend","value"="data"},"data":{"operator":">=","value":100}}
  54. """
  56. input_text="哪个便宜"
  57. #input_text="无限量哪个多少钱"
  58. #input_text="流量最大的多少钱"
  60. context = f"""
  61. 客服：有什么可以帮您
  62. 用户：有什么100G以上的套餐推荐
  63. 客服：我们有畅游套餐和无限套餐，您有什么价格倾向吗
  64. 用户：{input_text}
  65. """
  67. prompt = f"""
  68. {instruction}
  70. {output_format}
  72. {examples}
  74. {context}
  75. """
  77. response = get_completion(prompt)
  78. print(response)

{“sort”:{“ordering”=”ascend”,”value”=”price”},”data”:
{“operator”:”>=”,”value”:100}}

（1）用Prompt实现DST不是唯一选择
  • 优点: 节省开发量
  • 缺点: 调优相对复杂，最好用动态例子（讲Embedding时再review这个点）
（2）也可以用Prompt实现NLU，用传统方法维护DST
  • 优点: DST环节可控性更高
  • 缺点: 需要结合业务know-how设计状态更新机制（解冲突）

2.3.3、实现NLG和对话策略

我们先把刚才的能力串起来，构建一个简单的客服机器人

  1. # 加载环境变量
  2. import openai
  3. import os, json, copy
  5. from dotenv import load_dotenv, find_dotenv
  6. _ = load_dotenv(find_dotenv())  # 读取本地 .env 文件，里面定义了 OPENAI_API_KEY
  8. openai.api_key = os.getenv('OPENAI_API_KEY')
  10. instruction = """
  11. 你的任务是识别用户对手机流量套餐产品的选择条件。
  12. 每种流量套餐产品包含三个属性：名称(name)，月费价格(price)，月流量(data)。
  13. 根据用户输入，识别用户在上述三种属性上的倾向。
  14. """
  16. # 输出描述
  17. output_format = """
  18. 以JSON格式输出。
  19. 1. name字段的取值为string类型，取值必须为以下之一：经济套餐、畅游套餐、无限套餐、校园套餐 或 null；
  21. 2. price字段的取值为一个结构体 或 null，包含两个字段：
  22. (1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
  23. (2) value, int类型
  25. 3. data字段的取值为取值为一个结构体 或 null，包含两个字段：
  26. (1) operator, string类型，取值范围：'<='（小于等于）, '>=' (大于等于), '=='（等于）
  27. (2) value, int类型或string类型，string类型只能是'无上限'
  29. 4. 用户的意图可以包含按price或data排序，以sort字段标识，取值为一个结构体：
  30. (1) 结构体中以"ordering"="descend"表示按降序排序，以"value"字段存储待排序的字段
  31. (2) 结构体中以"ordering"="ascend"表示按升序排序，以"value"字段存储待排序的字段
  33. 只输出中只包含用户提及的字段，不要猜测任何用户未直接提及的字段。
  34. DO NOT OUTPUT NULL-VALUED FIELD! 确保输出能被json.loads加载。
  35. """
  37. examples = """
  38. 便宜的套餐：{"sort":{"ordering"="ascend","value"="price"}}
  39. 有没有不限流量的：{"data":{"operator":"==","value":"无上限"}}
  40. 流量大的：{"sort":{"ordering"="descend","value"="data"}}
  41. 100G以上流量的套餐最便宜的是哪个：{"sort":{"ordering"="ascend","value"="price"},"data":{"operator":">=","value":100}}
  42. 月费不超过200的：{"price":{"operator":"<=","value":200}}
  43. 就要月费180那个套餐：{"price":{"operator":"==","value":180}}
  44. 经济套餐：{"name":"经济套餐"}
  45. """
  47. class NLU:
  48.     def __init__(self):
  49.         self.prompt_template = f"{instruction}\n\n{output_format}\n\n{examples}\n\n用户输入：\n__INPUT__"
  50.     def _get_completion(self, prompt, model="gpt-3.5-turbo"):
  51.         messages = [{"role": "user", "content": prompt}]
  52.         response = openai.ChatCompletion.create(
  53.             model=model,
  54.             messages=messages,
  55.             temperature=0,  # 模型输出的随机性，0 表示随机性最小
  56.         )
  57.         semantics = json.loads(response.choices[0].message["content"])
  58.         return { k:v for k,v in semantics.items() if v }
  60.     def parse(self, user_input):
  61.         prompt = self.prompt_template.replace("__INPUT__",user_input)
  62.         return self._get_completion(prompt)
  64. class DST:
  65.     def __init__(self):
  66.         pass
  68.     def update(self, state, nlu_semantics):
  69.         if "name" in nlu_semantics:
  70.             state.clear()
  71.         if "sort" in nlu_semantics:
  72.             slot = nlu_semantics["sort"]["value"]
  73.             if slot in state and state[slot]["operator"] == "==":
  74.                 del state[slot]
  75.         for k, v in nlu_semantics.items():
  76.             state[k] = v
  77.         return state
  79. class MockedDB:
  80.     def __init__(self):
  81.         self.data = [
  82.             {"name":"经济套餐","price":50,"data":10,"requirement":None},
  83.             {"name":"畅游套餐","price":180,"data":100,"requirement":None},
  84.             {"name":"无限套餐","price":300,"data":1000,"requirement":None},
  85.             {"name":"校园套餐","price":150,"data":200,"requirement":"在校生"},
  86.         ]
  87.     def retrieve(self, **kwargs):
  88.         records = []
  89.         for r in self.data:
  90.             select = True
  91.             if r["requirement"]:
  92.                 if "status" not in kwargs or kwargs["status"]!=r["requirement"]:
  93.                     continue
  94.             for k, v in kwargs.items():
  95.                 if k == "sort":
  96.                     continue
  97.                 if k == "data" and v["value"] == "无上限":
  98.                     if r[k] != 1000:
  99.                         select = False
  100.                         break
  101.                 if "operator" in v:
  102.                     if not eval(str(r[k])+v["operator"]+str(v["value"])):
  103.                         select = False
  104.                         break
  105.                 elif str(r[k])!=str(v):
  106.                     select = False
  107.                     break
  108.             if select:
  109.                 records.append(r)
  110.         if len(records) <= 1:
  111.             return records
  112.         key = "price"
  113.         reverse = False
  114.         if "sort" in kwargs:
  115.             key = kwargs["sort"]["value"]
  116.             reverse = kwargs["sort"]["ordering"] == "descend"
  117.         return sorted(records,key=lambda x: x[key] ,reverse=reverse)
  119. class DialogManager:
  120.     def __init__(self, prompt_templates):
  121.         self.state = {}
  122.         self.session = [
  123.             {
  124.                 "role": "system",
  125.                 "content": "你是一个手机流量套餐的客服代表，你叫小瓜。可以帮助用户选择最合适的流量套餐产品。"
  126.             }
  127.         ]
  128.         self.nlu = NLU()
  129.         self.dst = DST()
  130.         self.db = MockedDB()
  131.         self.prompt_templates = prompt_templates
  133.     def _wrap(self,user_input,records):
  134.         if records:
  135.             prompt = self.prompt_templates["recommand"].replace("__INPUT__",user_input)
  136.             r = records[0]
  137.             for k,v in r.items():
  138.                 prompt = prompt.replace(f"__{k.upper()}__",str(v))
  139.         else:
  140.             prompt = self.prompt_templates["not_found"].replace("__INPUT__",user_input)
  141.             for k,v in self.state.items():
  142.                 if "operator" in v:
  143.                     prompt = prompt.replace(f"__{k.upper()}__",v["operator"]+str(v["value"]))
  144.                 else:
  145.                     prompt = prompt.replace(f"__{k.upper()}__",str(v))
  146.         return prompt
  148.     def _call_chatgpt(self, prompt, model="gpt-3.5-turbo"):
  149.         session = copy.deepcopy(self.session)
  150.         session.append({"role": "user", "content": prompt})
  151.         response = openai.ChatCompletion.create(
  152.             model=model,
  153.             messages=session,
  154.             temperature=0,
  155.         )
  156.         return response.choices[0].message["content"]
  158.     def run(self, user_input):
  159.         #调用NLU获得语义解析
  160.         semantics = self.nlu.parse(user_input)
  161.         print("===semantics===")
  162.         print(semantics)
  163.         #调用DST更新多轮状态
  164.         self.state = self.dst.update(self.state,semantics)
  165.         print("===state===")
  166.         print(self.state)
  167.         #根据状态检索DB，获得满足条件的候选
  168.         records = self.db.retrieve(**self.state)
  169.         #拼装prompt调用chatgpt
  170.         prompt_for_chatgpt = self._wrap(user_input, records)
  171.         print("===gpt-prompt===")
  172.         print(prompt_for_chatgpt)
  173.         #调用chatgpt获得回复
  174.         response = self._call_chatgpt(prompt_for_chatgpt)
  175.         #将当前用户输入和系统回复维护入chatgpt的session
  176.         self.session.append({"role": "user", "content": user_input})
  177.         self.session.append({"role": "assistant", "content": response})
  178.         return response

将垂直知识加入prompt，以使其准确回答

  1. prompt_templates = {
  2.     "recommand" : "用户说：__INPUT__ \n\n向用户介绍如下产品：__NAME__，月费__PRICE__元，每月流量__DATA__G。",
  3.     "not_found" : "用户说：__INPUT__ \n\n没有找到满足__PRICE__元价位__DATA__G流量的产品，询问用户是否有其他选择倾向。"
  4. }
  6. dm = DialogManager(prompt_templates)
  1. response = dm.run("流量大的")
  2. #response = dm.run("300太贵了，200元以内有吗")
  3. print("===response===")
  4. print(response)

===semantics=== {‘price’: {‘operator’: ‘<=’, ‘value’: 200}} ===state=== {‘sort’: {‘ordering’: ‘descend’, ‘value’: ‘data’}, ‘price’: {‘operator’: ‘<=’, ‘value’: 200}} ===gpt-prompt=== 用户说：300太贵了，200元以内有吗

向用户介绍如下产品：畅游套餐，月费180元，每月流量100G。 ===response=== 小瓜：非常抱歉，我们的无限套餐可能确实有些贵了。如果您的预算在200元以内，我可以向您推荐我们的畅游套餐。这个套餐每月只需支付180元，您将享受到每月100G的流量。虽然相比无限套餐流量稍少一些，但对于一般的上网需求来说已经足够了。如果您对这个套餐感兴趣，我可以帮您办理。还有其他的套餐选项，您有其他的需求吗？

增加约束：改变语气、口吻

  1. ext = "很口语，亲切一些。不用说“抱歉”。直接给出回答，不用在前面加“小瓜说：”。NO COMMENTS. NO ACKNOWLEDGEMENTS."
  2. prompt_templates = { k : v+ext for k, v in prompt_templates.items() }
  4. dm = DialogManager(prompt_templates)
  1. #response = dm.run("流量大的")
  2. response = dm.run("300太贵了，200元以内有吗")
  3. print("===response===")
  4. print(response)

===semantics===
{‘price’: {‘operator’: ‘<=’, ‘value’: 200}}
===state===
{‘sort’: {‘ordering’: ‘descend’, ‘value’: ‘data’}, ‘price’: {‘operator’: ‘<=’, ‘value’: 200}}
===gpt-prompt===
用户说：300太贵了，200元以内有吗

向用户介绍如下产品：畅游套餐，月费180元，每月流量100G。很口语，亲切一些。不用说“抱歉”。直接给出回答，不用在前面加“小瓜说：”。NO COMMENTS. NO ACKNOWLEDGEMENTS.
===response===
畅游套餐是您的不错选择！它每月只需180元，您将享受到100G的流量。这样您可以畅快地上网、观看视频和使用各种应用，而不用担心流量不够用。如果您对这个套餐感兴趣或有其他问题，随时告诉我哦！

以例子的形式实现对话策略

  1. ext = "\n\n遇到类似问题，请参照以下回答：\n你们流量包太贵了\n亲，我们都是全省统一价哦。"
  2. prompt_templates = { k : v+ext for k, v in prompt_templates.items() }
  4. dm = DialogManager(prompt_templates)
  1. response = dm.run("这流量包太贵了")
  2. print("===response===")
  3. print(response)

===semantics===
{‘sort’: {‘ordering’: ‘ascend’, ‘value’: ‘price’}}
===state===
{‘sort’: {‘ordering’: ‘ascend’, ‘value’: ‘price’}}
===gpt-prompt===
用户说：这流量包太贵了

向用户介绍如下产品：经济套餐，月费50元，每月流量10G。很口语，亲切一些。不用说“抱歉”。直接给出回答，不用在前面加“小瓜说：”。NO COMMENTS. NO ACKNOWLEDGEMENTS.

遇到类似问题，请参照以下回答：
你们流量包太贵了
亲，我们都是全省统一价哦。 ===response===
我们了解您的担忧，但是我们的流量套餐价格都是全省统一的哦。不过，如果您觉得当前的流量包价格有些高，我们还有一个经济套餐，每月只需支付50元，就可以享受10G的流量。这个套餐性价比非常高，您可以考虑一下哦。如果您有其他需求或者疑问，随时告诉我，我会尽力帮助您的。

划重点：
  1. 这里的例子可以动态添加
  2. 具体方法我们放在LangChain课程中结合Embedding一起讲解
作业：
      尝试自己通过NLU和Policy实现给在校生推荐“校园套餐”