(二)、基于 LangChain 实现大模型应用程序开发 | 对话记忆模块 Memory

😄 当我们在使用大型语言模型进行聊天对话时，大型语言模型本身实际上是无状态的。语言模型本身并不记得到目前为止的历史对话。每次调用API结点都是独立的。

⭐ 所以要想具备聊天对话功能，那肯定是要将历史对话记录存起来，下次对话时一同输入：历史对话记录+当前对话来得到输出。

🚀 Memory可以明确地存储到目前为止的所有术语或对话。这个Memory存储器被用作输入或附加上下文到LLM中，以便它可以生成一个输出，就好像它只有在进行下一轮对话的时候，才知道之前说过什么。

1、初始化openai环境 + 模型调用

from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI

import os
import openai
# 运行此API配置，需要将目录中的.env中api_key替换为自己的
from dotenv import load_dotenv, find_dotenv
_ = load_dotenv(find_dotenv()) # read local .env file
openai.api_key = os.environ['OPENAI_API_KEY']

# 这里我们将参数temperature设置为0.0，从而减少生成答案的随机性。
# 如果你想要每次得到不一样的有新意的答案，可以尝试调整该参数。
# 以下的对话均无记忆，即每次调用预测不会记得之前的对话。（想要有记忆功能请看下一节的langchain的Memory模块）
chat = ChatOpenAI(temperature=0.0,
                  model_name="gpt-3.5-turbo")
chat

2、ConversationBufferMemory()

• 用于缓存所有对话记录

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()
# #也可预先向缓存区添加指定对话的输入输出
# memory.save_context({"input": "Hi"},
#                     {"output": "What's up"})
# print(memory.buffer) # 历史对话信息会存在memory.buffer里
#新建一个对话链（关于链后面会提到更多的细节）
conversation = ConversationChain(
    llm=chat,
    memory = memory,
    verbose=True   #查看Langchain实际上在做什么，设为FALSE的话只给出回答，看不到下面绿色的内容
)

conversation.predict(input='你好，我是小徐，也可以叫我爸爸')

输出：

> Entering new ConversationChain chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
Human: 你好，我是小徐
AI: 你好，小徐！很高兴认识你。我是一个AI助手，可以回答你的问题和提供帮助。有什么我可以帮你的吗？
Human: 你好，我是小徐，也可以叫我爸爸
AI:

> Finished chain.

'你好，小徐爸爸！很高兴认识你。有什么我可以帮你的吗？'

当我们进行下一轮对话时，他会保留之前对话的提示(若不需要这些提示，可在构建ConversationChain设置：verbose=False)

conversation.predict(input='1+1=？')

> Entering new  chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
Human: 你好，我是小徐
AI: 你好，小徐！很高兴认识你。我是一个AI助手，可以回答你的问题和提供帮助。有什么我可以帮你的吗？
Human: 1+1=？
AI:

> Finished chain.

'1+1=2'

conversation.predict(input='我叫什么名字')

> Entering new  chain...
Prompt after formatting:
The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.

Current conversation:
Human: 你好，我是小徐
AI: 你好，小徐！很高兴认识你。我是一个AI助手，可以回答你的问题和提供帮助。有什么我可以帮你的吗？
Human: 1+1=？
AI: 1+1=2
Human: 我叫什么名字
AI:

> Finished chain.

'你叫小徐。'

memory.buffer存储了当前为止所有的对话信息：

print(memory.buffer)

Human: 你好，我是小徐
AI: 你好，小徐！很高兴认识你。我是一个AI助手，可以回答你的问题和提供帮助。有什么我可以帮你的吗？
Human: 1+1=？
AI: 1+1=2
Human: 我叫什么名字
AI: 你叫小徐。

添加指定的输入输出内容到记忆缓存区：

memory = ConversationBufferMemory()  #新建一个空的对话缓存记忆
memory.save_context({"input": "Hi"},    #向缓存区添加指定对话的输入输出
                    {"output": "What's up"})
print(memory.buffer)   #查看缓存区结果
# Human: Hi
# AI: What's up

3、ConversationBufferWindowMemory()

• 因为现在chatgpt都是按输入/输出的token数收费的，所以如果长期对话，那保留来所有历史对话记录，那得多烧钱啊，每次输入一大堆。
• 对话缓存窗口记忆：只保留一个窗口大小的对话缓存区窗口记忆。它只使用最近的n次交互。这可以用于保持最近交互的滑动窗口，以便缓冲区不会过大。

from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationChain

# 用法和上面一样
memory = ConversationBufferWindowMemory(k=1)     # k=1表明只保留一个对话记忆
print(memory.buffer) # 历史对话信息会存在memory.buffer里
#新建一个对话链（关于链后面会提到更多的细节）
conversation = ConversationChain(
    llm=chat,
    memory = memory,
    verbose=False   #查看Langchain实际上在做什么，设为FALSE的话只给出回答，看到不到下面绿色的内容
)


print(conversation.predict(input="你好, 我叫小徐"))
print(conversation.predict(input="1+1等于多少？"))
print(conversation.predict(input="我叫什么名字？"))

# 你好小徐！很高兴认识你。我是一个AI助手，我可以回答你的问题或者和你聊天。有什么我可以帮助你的吗？
# 1+1等于2。这是一个非常简单的数学问题。
# 很抱歉，我无法知道您的名字。

4、ConversationTokenBufferMemory()

• 对话token缓存记忆：使用对话token缓存记忆，内存将限制保存的token数量。如果token数量超出指定数目，它会切掉这个对话的早期部分 以保留与最近的交流相对应的token数量，但不超过token限制。
• chatgpt是如何计算token数的，可参考这：https://www.zhihu.com/question/594159910
• openai开源的计算token数量的库tiktoken：https://github.com/openai/tiktoken

from langchain.memory import ConversationTokenBufferMemory
from langchain.chains import ConversationChain

# 用法和上面一样
memory = ConversationTokenBufferMemory(llm=chat, max_token_limit=10) # 因为要算token，所以加llm的tokenizer进来切token计算
print(memory.buffer) # 历史对话信息会存在memory.buffer里
#新建一个对话链（关于链后面会提到更多的细节）
conversation = ConversationChain(
    llm=chat,
    memory = memory,
    verbose=False   #查看Langchain实际上在做什么，设为FALSE的话只给出回答，看到不到下面绿色的内容
)

5、ConversationSummaryBufferMemory()

• 对话摘要缓存记忆：不将内存限制为基于最近对话的固定数量的token或固定数量的对话次数窗口，而是使用LLM编写到目前为止历史对话的摘要，并将其保存。

from langchain.memory import ConversationSummaryBufferMemory
from langchain.chains import ConversationChain

# 用法和上面一样
memory = ConversationSummaryBufferMemory(llm=chat, max_token_limit=20) # 因为要算token和摘要，所以加llm的tokenizer进来切token计算
print(memory.buffer) # 历史对话信息会存在memory.buffer里
#新建一个对话链（关于链后面会提到更多的细节）
conversation = ConversationChain(
    llm=chat,
    memory = memory,
    verbose=False   #查看Langchain实际上在做什么，设为FALSE的话只给出回答，看到不到下面绿色的内容
)

# 瞧一瞧是不是真的对历史对话有摘要功能
memory.save_context({"input": "小徐喜欢小雯"}, {"output": "听说好像确实是这样的"})
memory.save_context({"input": "小雯也喜欢小徐"}, {"output": "应该是"})
memory.save_context({"input": "他们喜欢咪咪"}, {"output": "是的"})
# 也就是将历史对话摘要后转成了SystemMessage
memory.load_memory_variables({})['history']

'System: The AI agrees that Xiaoxu likes Xiaowen and responds with "应该是" (should be). The human then adds that they both like Mimi. The AI responds with "是的" (yes) and says that it has heard that it is indeed the case. The human adds that Xiaowen also likes Xiaoxu.\nAI: 是的'

Reference

• [1] 吴恩达老师的教程
• [2] DataWhale组织