当前位置:   article > 正文

AIGC|LangChain新手入门指南,5分钟速读版!_langchain入门指南.pdf

langchain入门指南.pdf

如果你用大语言模型来构建AI应用,那你一定不可能绕过LangChain,LangChain是现在最热门的AI应用框架之一,去年年底才刚刚发布,它在github上已经有了4.6万颗星的点赞了,在github社区上,每天都有众多大佬,用它创造一些很新很酷的应用。


今天就带大家看看这个LangChain是什么,看看它凭什么能众多大佬如此兴奋呢?

目录

一、什么是LangChain

二、LangChain 六大模块

1、Models

2、Prompts

3、Chains

4、Memory

5、indexes

6、Agenta&Tools

三、其他功能

1、结构化输出

2、对超长文本进行总结

3、本地问答机器人

一、什么是LangChain

LangChain是一个基于大语言模型的端到端应用程序开发框架。下面我们通过一个例子来感受一下它的用途和优势。

假设我想使用ChatGPT的大语言模型构建一个应用程序,并将自己的数据(如notion数据库、pdf、电子邮件、txt等)与之结合。

然而,GPT-4的训练数据截止到2021年9月(本文写于开通联网功能之前),因此它对之后发生的事件并不了解。我想让这个程序能够访问互联网,如谷歌搜索、维基百科等,并成为“智多星”。

此外,我还想要根据用户输入的计划构建提示,并保留用户的存储历史记录。

单一的GPT模型可能无法满足需求,我还希望能够支持多个大语言模型。

这个强大的程序需要很多考虑的东西,而且实现起来非常复杂。

不过没问题!

我们用LangChain就可以简单解决!

在开始学习之前,请确保您的计算机上安装了Python环境、科学上网工具以及LLM的相关密钥。

LLM的具体配置请参考Integrations — LangChain 0.0.194

本文使用的OpenAI的key。

二、LangChain 六大模块

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

1、Models

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

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

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

2、Prompts

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

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

3、Chains

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

  1. importos
  2. fromapikey importapikey
  3. importstreamlit asst
  4. fromlangchain.llms importOpenAI
  5. fromlangchain.prompts importPromptTemplate
  6. fromlangchain.chains importLLMChain,SequentialChain
  7. os.environ["OPENAI_API_KEY"] = apikey
  8. st.title('标题搜索chains')
  9. prompt =st.text_input('在这输入你的想搜索的标题')
  10. title_template=PromptTemplate(
  11. input_variables = ['topic'],
  12. template='写一个标题关于{topic}'
  13. )
  14. scripts_template=PromptTemplate(
  15. input_variables = ['title'],
  16. template='写一个脚本关于这个标题:{title}'
  17. )
  18. #Llms
  19. llm = OpenAI(temperature=0)
  20. title_chain =LLMChain(llm =llm,prompt =title_template,verbose= True,output_key='title')
  21. scripts_chain=LLMChain(llm =llm,prompt =scripts_template,verbose= True,output_key='script')
  22. #链
  23. sequential_chain =SequentialChain(chains=[title_chain,scripts_chain],input_variables=['topic'],output_variables=['title','script'],verbose=True)
  24. ifprompt:
  25. response =sequential_chain({'topic':prompt})
  26. st.write(response['title'])
  27. st.write(response['script'])

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

4、Memory

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

  1. importos
  2. fromapikey importapikey
  3. importstreamlit asst
  4. fromlangchain.llms importOpenAI
  5. fromlangchain.prompts importPromptTemplate
  6. fromlangchain.chains importLLMChain,SequentialChain
  7. fromlangchain.memory importConversationBufferMemory
  8. os.environ["OPENAI_API_KEY"] = apikey
  9. st.title('标题搜索chains')
  10. prompt =st.text_input('在这输入你的想搜索的标题')
  11. title_template=PromptTemplate(
  12. input_variables = ['topic'],
  13. template='写一个标题关于{topic}'
  14. )
  15. scripts_template=PromptTemplate(
  16. input_variables = ['title'],
  17. template='写一个脚本关于这个标题:{title}'
  18. )
  19. #历史
  20. memory = ConversationBufferMemory(input_key="topic",memory_key ='chat_history')
  21. #Llms
  22. llm = OpenAI(temperature=0)
  23. title_chain =LLMChain(llm =llm,prompt =title_template,verbose=True,output_key='title',memory=memory)
  24. scripts_chain=LLMChain(llm =llm,prompt=scripts_template,verbose= True,output_key='script',memory=memory)
  25. #链
  26. sequential_chain =SequentialChain(chains=[title_chain,scripts_chain],input_variables=['topic'],output_variables=['title','script'],verbose=True)
  27. ifprompt:
  28. response =sequential_chain({'topic':prompt})
  29. st.write(response['title'])
  30. st.write(response['script'])
  31. # 添加显示
  32. withst.expander("历史记录"):
  33. st.info(memory.buffer)

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

5、indexes

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

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

6、Agenta&Tools

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

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

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

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

三、其他功能

这里找了几个比较实用的功能,感兴趣的同学可以玩一下,互相探讨一下

1、结构化输出

  1. importos
  2. fromlangchain.output_parsers importStructuredOutputParser, ResponseSchema
  3. fromlangchain.prompts importPromptTemplate
  4. fromlangchain.llms importOpenAI
  5. os.environ["OPENAI_API_KEY"] = '***************'
  6. llm = OpenAI(model_name="text-davinci-003")
  7. # 告诉他我们生成的内容需要哪些字段,每个字段类型式
  8. response_schemas = [
  9. ResponseSchema(name="bad_string", description="This a poorly formatted user input string"),
  10. ResponseSchema(name="good_string", description="This is your response, a reformatted response")
  11. ]
  12. output_parser = StructuredOutputParser.from_response_schemas(response_schemas)
  13. format_instructions = output_parser.get_format_instructions()
  14. template = """
  15. You will be given a poorly formatted string from a user.
  16. Reformat it and make sure all the words are spelled correctly
  17. {format_instructions}
  18. % USER INPUT:
  19. {user_input}
  20. YOUR RESPONSE:
  21. """
  22. # 讲我们的格式描述嵌入到 prompt 中去,告诉 llm 我们需要他输出什么样格式的内容
  23. prompt = PromptTemplate(
  24. input_variables=["user_input"],
  25. partial_variables={"format_instructions": format_instructions},
  26. template=template
  27. )
  28. promptValue = prompt.format(user_input="welcom to califonya!")
  29. llm_output = llm(promptValue)
  30. parse = output_parser.parse(llm_output)
  31. print(parse)

2、对超长文本进行总结

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

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

3、本地问答机器人

安装向量数据库chromadb和tiktoken。


其中chromadb电脑要有C++环境,使用教程:Chroma向量数据库 - BimAnt

  1. pip installchromadb
  2. pip installtiktoken

在项目里面放一个doc.txt,内容可以放自己需要的。

  1. importos
  2. fromlangchain.embeddings.openai importOpenAIEmbeddings
  3. fromlangchain.vectorstores importChroma
  4. fromlangchain.text_splitter importCharacterTextSplitter
  5. fromlangchain importOpenAI, VectorDBQA
  6. fromlangchain.document_loaders importDirectoryLoader
  7. fromlangchain.chains importRetrievalQA
  8. os.environ["OPENAI_API_KEY"] = '**********************'
  9. # 加载文件夹中的所有txt类型的文件
  10. loader = DirectoryLoader('D:\你项目地址', glob='**/*.txt')
  11. # 将数据转成 document 对象,每个文件会作为一个 document
  12. documents = loader.load()
  13. text_splitter = CharacterTextSplitter(chunk_size=100, chunk_overlap=0)
  14. # 切割加载的 document
  15. split_docs = text_splitter.split_documents(documents)
  16. embeddings = OpenAIEmbeddings()
  17. # 将 document 通过 openai 的 embeddings 对象计算 embedding 向量信息并临时存入 Chroma 向量数据库,用于后续匹配查询
  18. docsearch = Chroma.from_documents(split_docs, embeddings)
  19. # 创建问答对象
  20. qa = VectorDBQA.from_chain_type(llm=OpenAI(), chain_type="stuff", vectorstore=docsearch, return_source_documents=True)
  21. # 进行问答
  22. result = qa({"query": "有哪些开心的事情?"})
  23. print(result)importos
  24. fromlangchain.embeddings.openai importOpenAIEmbeddings
  25. fromlangchain.vectorstores importChroma
  26. fromlangchain.text_splitter importCharacterTextSplitter
  27. fromlangchain importOpenAI, VectorDBQA
  28. fromlangchain.document_loaders importDirectoryLoader
  29. fromlangchain.chains importRetrievalQA
  30. # openAI的Key
  31. os.environ["OPENAI_API_KEY"] = '**********************'
  32. # 加载文件夹中的所有txt类型的文件
  33. loader = DirectoryLoader('D:\pythonwork\mindlangchain\data', glob='**/*.txt')
  34. # 将数据转成 document 对象,每个文件会作为一个 document
  35. documents = loader.load()
  36. # 初始化加载器
  37. text_splitter = CharacterTextSplitter(chunk_size=100, chunk_overlap=0)
  38. # 切割加载的 document
  39. split_docs = text_splitter.split_documents(documents)
  40. # 初始化 openai 的 embeddings 对象
  41. embeddings = OpenAIEmbeddings()
  42. # 将 document 通过 openai 的 embeddings 对象计算 embedding 向量信息并临时存入 Chroma 向量数据库,用于后续匹配查询
  43. docsearch = Chroma.from_documents(split_docs, embeddings)
  44. # 创建问答对象
  45. qa = VectorDBQA.from_chain_type(llm=OpenAI(), chain_type="stuff", vectorstore=docsearch, return_source_documents=True)
  46. # 进行问答,对txt中的文字查找
  47. result = qa({"query": "询问一些与txt存入的信息相关的问题?"})
  48. print(result)

本文的初衷是促进大家之间的交流和学习。如果您发现任何错误或不足之处,请及时提出,我们一起学习、更正和进步。

非常欢迎大家加入社群与我们进行交流,共同成长,一起学习,一起进步。

分享者:方宇航| 后端开发工程师

更多AI小知识欢迎关注“神州数码云基地”公众号,回复“AI与数字化转型”进入社群交流

版权声明:文章由神州数码武汉云基地团队实践整理输出,转载请注明出处。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家自动化/article/detail/70993
推荐阅读
相关标签
  

闽ICP备14008679号