使用 Google Colab 部署 LLaMA-13B 及 LangChain 实战

LCEL（LangChain 表达式语言）是核心概念之一，允许创建提示并将其绑定到语言模型：

from langchain.prompts import PromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.callbacks.tracers import ConsoleCallbackHandler

template = """<s>[INST] <<SYS>> Provide a correct and short answer to the question. <</SYS>> {question} [/INST]"""
prompt = PromptTemplate(template=template, input_variables=["question"])
chain = prompt | llm | StrOutputParser()
chain.invoke({"question":"What is the distance to the Moon?"}, config={# "callbacks": [ConsoleCallbackHandler()]})

这里创建了指示 LLaMA 模型行为的提示，连接到 LLM，并添加 StrOutputParser 清理输出。callbacks 是可选参数，用于调试链；若查看实际发送给模型的提示，它非常有用。

合并链

使用 LCEL 可轻松组合两个链，将第一个链的输出作为第二个链的输入：

template2 = """<s>[INST] <<SYS>> Use the summary {summary} and give 2 one sentence examples of practical applications of the subject [/INST] <</SYS>> [/INST] """
prompt2 = PromptTemplate(input_variables=["summary"], template=template2,)
chain2 = {"summary": prompt | llm | StrOutputParser()}| prompt2 | llm | StrOutputParser()
chain2.invoke({"question":"What is the distance to the Moon?"}, config={# "callbacks": [ConsoleCallbackHandler()]})

若启用 ConsoleCallbackHandler，会看到语言模型被调用了两次。LangChain 在幕后处理所有调用，这点需牢记，尤其是使用付费 API 时，未意识到的多次调用可能导致账单激增。

自动路由

测试更复杂的例子，为不同请求使用不同提示。使用 HuggingFaceEmbeddings 类和余弦相似度确定问题是否关于空间或数学：

from langchain.embeddings import HuggingFaceEmbeddings
from langchain.utils.math import cosine_similarity
from langchain.schema.runnable import RunnableLambda, RunnablePassthrough

space_template = """<s>[INST] <<SYS>> You are an astronaut. You are great at answering questions about space. Provide a short answer to the question, understandable to a small kid. <</SYS>> {query} [/INST]"""
math_template = """<s>[INST] <<SYS>> You are a mathematician. You are great at answering math questions. Provide a short answer to the question. <</SYS>> {query} [/INST]"""
embeddings = HuggingFaceEmbeddings()
prompt_templates = [space_template, math_template]
prompt_embeddings = embeddings.embed_documents(prompt_templates)

def prompt_router(input):
    query_embedding = embeddings.embed_query(input["query"])
    similarity = cosine_similarity([query_embedding], prompt_embeddings)[0]
    most_similar = prompt_templates[similarity.argmax()]
    print("Using MATH" if most_similar == math_template else "Using SPACE")
    return PromptTemplate.from_template(most_similar)

chain = ({"query": RunnablePassthrough()}| RunnableLambda(prompt_router)| llm | StrOutputParser())

逻辑很简单：将问题转换为数值表示，用余弦相似度判断更接近'数学'还是'空间'。如果问题是不同的人提出的，例如成人和孩子，自动提示检测很有用。

基本聊天

使用 ChatPromptTemplate 类与 LLM 进行对话交互：

from langchain.chains import LLMChain
from langchain.prompts.chat import ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate
from langchain.schema import AIMessage, HumanMessage
from langchain_experimental.chat_models import Llama2Chat

sys_template = """<s>[INST] <<SYS>> Act as an experienced AI assistant. Write only one sentence answers. <</SYS>> [/INST] """
chat_prompt = ChatPromptTemplate.from_messages([
    SystemMessagePromptTemplate.from_template(sys_template),
    HumanMessage(content="Hello, how are you doing?"),
    AIMessage(content="I'm doing well, thanks!"),
    HumanMessage(content="May I ask you a question about Moon?"),
    AIMessage(content="Yes, sure."),
    HumanMessagePromptTemplate.from_template("{question}"),
])
model = Llama2Chat(llm=llm)
chain = chat_prompt | model | StrOutputParser()
chain.invoke({"question":"How big is it?"}, config={# "callbacks": [ConsoleCallbackHandler()]})

这里创建了包含指令的系统消息模板，并添加了对话历史。LangChain 将这些数据组合成最终提示。我们可以启用 ConsoleCallbackHandler 查看发送给模型的输入。

带记忆和消息摘要的聊天

将所有消息存储在文本体中会导致提示过长。借助 ConversationSummaryMemory 类，我们可以只保留大致内容：

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory, CombinedMemory, ChatMessageHistory

conv_memory = ConversationBufferMemory(memory_key="chat_history_lines", input_key="input")
summary_memory = ConversationSummaryMemory(llm=llm, input_key="input")
memory = CombinedMemory(memories=[conv_memory, summary_memory])

template = """<s>[INST] <<SYS>> Act as an experienced AI assistant. Write one-sentence answers only. <</SYS>> Summary of conversation: {history} Current conversation: {chat_history_lines} Human: {input} [/INST] """

summary_memory.save_context({"input":"Hi, how are you"},{"output":"Thanks, I am fine"})
summary_memory.save_context({"input":"May I ask you questions about Moon?"},{"output":"Yes, sure"})
summary_memory.load_memory_variables({})

prompt = PromptTemplate(input_variables=["history","input","chat_history_lines"], template=template,)
conversation = ConversationChain(llm=llm, verbose=True, memory=memory, prompt=prompt)
conversation.run("How far is it?")
conversation.run("And what about Mars?")

问题和回答看似简单，但幕后有很多工作。每当添加新的'请求 - 响应'对时，ConversationSummaryMemory 都会调用 LLM。对于简短对话，序列看起来是这样的：每次调用 ConversationChain 时，摘要也会自动更新。这里有几个值得注意的地方：会话摘要并不总是完美的，输出可能较长；测试中链有时会因标记数超过限制而报错；LLM 被执行了多次，这对本地模型不重要，但在付费 API 下可能会产生额外费用。

代理

将外部代理与语言模型连接起来，允许模型使用'工具'完成具体任务。这里使用 PythonREPLTool 类，允许模型执行 Python 代码：

from langchain_experimental.tools import PythonREPLTool
tool = PythonREPLTool()
tool.run('import math; print(math.sqrt(5))')

这个类内部没有合理性检查，可能存在危险。如果用户要求删除系统文件，该工具可能会毫不犹豫地执行。

要使用 Python 代理，只需几行代码：

from langchain_experimental.agents.agent_toolkits import create_python_agent
from langchain.agents.agent_types import AgentType

agent = create_python_agent(llm=llm, tool=tool, verbose=True, agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
agent.agent.llm_chain.verbose = True
agent.run("What is a square root of 5?")

输出显示提示模板相当复杂，7B 模型难以完成，13B 模型虽能完成任务但结果不一致。LLM 被调用多次，存在安全隐患。如果允许用户在系统上运行任意 Python 代码，可能会有严重的安全问题。目前在生产环境中使用 Python 代理仍需谨慎，但从自我教育角度看，了解其工作原理很有趣。

总结

大型语言模型的使用非常有趣。在这篇文章中，我们在免费的 Google Colab 实例上运行了 LLaMA-13B 模型，仅使用免费组件测试了其功能。开源 LangChain 库允许我们用几行代码完成复杂的事情，比如制作聊天摘要。LLaMA.cpp 也是一个有趣的项目，允许我们使用 LLaMA 及其他语言模型和不同的硬件。能够免费运行语言模型和框架对于实验、原型制作或自我教育来说是非常棒的。