LangChain学习

官方定义是：LangChain是一个强大的框架，旨在帮助开发人员使用语言模型构建端到端的应用程序，它提供了一套工具、组件和接口，可简化创建由大型语言模型 (LLM) 和聊天模型提供支持的应用程序的过程。LangChain是一个语言模型集成框架，其使用案例与语言模型的使用案例大致重叠，包括文档分析和摘要、聊天机器人和代码分析。

LangChain 六大模块

LangChain允许通过组合性的使用LLMs构建应用程序，它目前提供了六种不同的关键功能，这些功能被分为不同的模块。

1、Models

第一个也是最重要的一个 Models ,LangChain为许多LLMs提供了通用的接口，我们可以从OpenAI,HuggingFace,Cohere等等的公司来获取模型。

importos
fromlangchain.llms importOpenAI
os.environ["OPENAI_API_KEY"] = '***************'
llm = OpenAI(model_name="text-davinci-003")
result =llm("请告诉我云基地厉害不")
print(result)

恭喜你入门了，这样你就掌握了如何使用LLM接下来我们继续学习更多有意思的东西。

2、Prompts

包括即使管理、即使优化和即使序列化 ,比如我们可以定义用户输入的模板为最终的提示词

fromlangchain.prompts importPromptTemplate
prompt =PromptTemplate(
input_variables = ['question'],
template='现在你是你是代码专家，请告诉我如何解决{question}'
)
user_input =input("你的代码疑惑")
prompt(question=user_input)

3、Chains

表示我们可以按调用多个LLM,我们可以将许多LLM和Prompts结合起来，不同的组合能达到不同效果，并且这个组合的方式是无穷无尽的，方便展示我将用到streamlit做一个简单的页面展示

importos
fromapikey importapikey
importstreamlit asst
fromlangchain.llms importOpenAI
fromlangchain.prompts importPromptTemplate
fromlangchain.chains importLLMChain,SequentialChainos.environ["OPENAI_API_KEY"] = apikeyst.title('标题搜索chains') 
prompt =st.text_input('在这输入你的想搜索的标题')
title_template=PromptTemplate(
input_variables = ['topic'],
template='写一个标题关于{topic}'
)
scripts_template=PromptTemplate(
input_variables = ['title'],
template='写一个脚本关于这个标题:{title}'
)#Llms
llm = OpenAI(temperature=0)
title_chain =LLMChain(llm =llm,prompt =title_template,verbose= True,output_key='title')
scripts_chain=LLMChain(llm =llm,prompt =scripts_template,verbose= True,output_key='script')
#链
sequential_chain =SequentialChain(chains=[title_chain,scripts_chain],input_variables=['topic'],output_variables=['title','script'],verbose=True)
ifprompt:
response =sequential_chain({'topic':prompt})
st.write(response['title'])
st.write(response['script'])

这样就可以链接多个Prompts，查出我们想要的标题和脚本了

4、Memory

LangChain提供了一个标准的内存接口和一个内存实现集合，我们可以存储聊天的记录

importos
fromapikey importapikey
importstreamlit asst
fromlangchain.llms importOpenAI
fromlangchain.prompts importPromptTemplate
fromlangchain.chains importLLMChain,SequentialChain
fromlangchain.memory importConversationBufferMemoryos.environ["OPENAI_API_KEY"] = apikeyst.title('标题搜索chains')
prompt =st.text_input('在这输入你的想搜索的标题')
title_template=PromptTemplate(
input_variables = ['topic'],
template='写一个标题关于{topic}'
)
scripts_template=PromptTemplate(
input_variables = ['title'],
template='写一个脚本关于这个标题:{title}'
)
#历史
memory = ConversationBufferMemory(input_key="topic",memory_key ='chat_history')#Llms
llm = OpenAI(temperature=0)
title_chain =LLMChain(llm =llm,prompt =title_template,verbose=True,output_key='title',memory=memory)
scripts_chain=LLMChain(llm =llm,prompt=scripts_template,verbose= True,output_key='script',memory=memory)
#链
sequential_chain =SequentialChain(chains=[title_chain,scripts_chain],input_variables=['topic'],output_variables=['title','script'],verbose=True)
ifprompt:
response =sequential_chain({'topic':prompt})
st.write(response['title'])
st.write(response['script'])
# 添加显示
withst.expander("历史记录"):
st.info(memory.buffer)

我们可以存入数据库去留下更多的数据

5、indexes

这个模块包含许多使用的函数，可以将我们的模型和自己的文本数据进行结合，可以获取不同的源数据，并且它还提供了矢量储存的接口来有效的存储文本并使其可搜索。

感兴趣的朋友可以研究下：传送门indexes

6、Agenta&Tools

这也是个非常强大的模块，可以设置代理建立于谷歌、维基百科、计算器等强大的生物语言模型。

这里有个通过 Google 搜索并返回答案的例子可以体验一下。

importos
fromlangchain.agents importload_tools
fromlangchain.agents importinitialize_agent
fromlangchain.llms importOpenAI
fromlangchain.agents importAgentTypeos.environ["OPENAI_API_KEY"] = '********************'
os.environ["SERPAPI_API_KEY"] = '**********************'
llm = OpenAI(temperature=0, max_tokens=2048)# tools
tools = load_tools(["serpapi"])agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
"""
agent：代理类型 
zero-shot-react-description: 根据工具的描述和请求内容的来决定使用哪个工具（最常用）
react-docstore: 使用 ReAct 框架和 docstore 交互, 使用Search 和Lookup 工具, 前者用来搜, 后者寻找term, 举例: Wipipedia 工具
self-ask-with-search 此代理只使用一个工具: Intermediate Answer, 它会为问题寻找事实答案(指的非 gpt 生成的答案, 而是在网络中,文本中已存在的), 如 Google search API 工具
conversational-react-description: 为会话设置而设计的代理, 它的prompt会被设计的具有会话性, 且还是会使用 ReAct 框架来决定使用来个工具, 并且将过往的会话交互存入内存
"""# 运行 agent
agent.run("今天星期几?，历史上的今天发生了哪些大事")

这个可以弥补OpenAI数据库中没有的问题，我们可以去谷歌去搜索，相对应的tool还有维基百科等等，还有计算器相关的tool等待大家探索

结构化输出

importosfromlangchain.output_parsers importStructuredOutputParser, ResponseSchema
fromlangchain.prompts importPromptTemplate
fromlangchain.llms importOpenAIos.environ["OPENAI_API_KEY"] = '***************'llm = OpenAI(model_name="text-davinci-003")# 告诉他我们生成的内容需要哪些字段，每个字段类型式
response_schemas = [
ResponseSchema(name="bad_string", description="This a poorly formatted user input string"),
ResponseSchema(name="good_string", description="This is your response, a reformatted response")
]output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
format_instructions = output_parser.get_format_instructions()template = """
You will be given a poorly formatted string from a user.
Reformat it and make sure all the words are spelled correctly
{format_instructions}
% USER INPUT:
{user_input}
YOUR RESPONSE:
"""# 讲我们的格式描述嵌入到 prompt 中去，告诉 llm 我们需要他输出什么样格式的内容
prompt = PromptTemplate(
input_variables=["user_input"],
partial_variables={"format_instructions": format_instructions},
template=template
)promptValue = prompt.format(user_input="welcom to califonya!")
llm_output = llm(promptValue)parse = output_parser.parse(llm_output)
print(parse)

对超长文本进行总结

准备一个超长问题：你的长文本.txt

importosfromlangchain.document_loaders importUnstructuredFileLoader
fromlangchain.chains.summarize importload_summarize_chain
fromlangchain.text_splitter importRecursiveCharacterTextSplitter
fromlangchain importOpenAIos.environ["OPENAI_API_KEY"] = '**********'
os.environ["SERPAPI_API_KEY"] = '**********'# 导入文本
loader = UnstructuredFileLoader(fr"D:\你的长文本路径.txt")
# 将文本转成 Document 对象
document = loader.load()
print(f'documents:{len(document)}')# 初始化文本分割器
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=500,
chunk_overlap=0
)# 切分文本
split_documents = text_splitter.split_documents(document)
print(f'documents:{len(split_documents)}')# 加载 llm 模型
llm = OpenAI(model_name="text-davinci-003", max_tokens=1500)# 创建总结链
chain = load_summarize_chain(llm, chain_type="refine", verbose=True)
"""
chain_type：chain类型stuff: 这种最简单粗暴，会把所有的 document 一次全部传给 llm 模型进行总结。如果document很多的话，势必会报超出最大 token 限制的错，所以总结文本的时候一般不会选中这个。map_reduce: 这个方式会先将每个 document 进行总结，最后将所有 document 总结出的结果再进行一次总结。refine: 这种方式会先总结第一个 document，然后在将第一个 document 总结出的内容和第二个 document 一起发给 llm 模型在进行总结，以此类推。这种方式的好处就是在总结后一个 document 的时候，会带着前一个的 document 进行总结，给需要总结的 document 添加了上下文，增加了总结内容的连贯性。
这种一般不会用在总结的 chain 上，而是会用在问答的 chain 上，他其实是一种搜索答案的匹配方式。首先你要给出一个问题，他会根据问题给每个 document 计算一个这个 document 能回答这个问题的概率分数，然后找到分数最高的那个 document ，在通过把这个 document 转化为问题的 prompt 的一部分（问题+document）发送给 llm 模型，最后 llm 模型返回具体答案。
"""
# 执行总结链，（为了快速演示，只总结前5段）
chain.run(split_documents[:5])