devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

[浦语大模型笔记三」Langchain搭建你的本地知识库_langchain 本地知识库

作者：从前慢现在也慢 | 2024-04-22 04:39:01

赞

踩

langchain 本地知识库

     第三节课主要讲解如何在InternStudio平台基于InternLM7B模型通过Langchain搭建本地知识库模型。主讲人为皱雨衡大佬，同样这里放出源文档连接tutorial/langchain/readme.md at main · InternLM/tutorial (github.com)。

一.Langchain相关环境配置

在已完成 InternLM 的部署基础上，还需要安装以下依赖包：

  1. pip install langchain==0.0.292
  2. pip install gradio==4.4.0
  3. pip install chromadb==0.4.15
  4. pip install sentence-transformers==2.2.2
  5. pip install unstructured==0.10.30
  6. pip install markdown==3.3.7

同时，我们需要使用到开源词向量模型 Sentence Transformer:（我们也可以选用别的开源词向量模型来进行 Embedding，目前选用这个模型是相对轻量、支持中文且效果较好的，同学们可以自由尝试别的开源词向量模型）

首先需要使用 huggingface 官方提供的 huggingface-cli 命令行工具。安装依赖:

pip install -U huggingface_hub

然后在和 /root/data 目录下新建python文件 download_hf.py，填入以下代码：

  • resume-download：断点续下
  • local-dir：本地存储路径。（linux环境下需要填写绝对路径）
  1. import os
  2.  
  3. # 下载模型
  4. os.system('huggingface-cli download --resume-download sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 --local-dir /root/data/model/sentence-transformer')

但是，使用 huggingface 下载可能速度较慢，我们可以使用 huggingface 镜像下载。与使用hugginge face下载相同，只需要填入镜像地址即可。

将 download_hf.py 中的代码修改为以下代码：

  1. import os
  2.  
  3. # 设置环境变量
  4. os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
  5.  
  6. # 下载模型
  7. os.system('huggingface-cli download --resume-download sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 --local-dir /root/data/model/sentence-transformer')

然后，在 /root/data 目录下执行该脚本即可自动开始下载：

python download_hf.py

更多关于镜像使用可以移步至 HF Mirror 查看。

下载 NLTK 相关资源

我们在使用开源词向量模型构建开源词向量的时候，需要用到第三方库 nltk 的一些资源。正常情况下，其会自动从互联网上下载，但可能由于网络原因会导致下载中断，此处我们可以从国内仓库镜像地址下载相关资源，保存到服务器上。

我们用以下命令下载 nltk 资源并解压到服务器上：

  1. cd /root
  2. git clone https://gitee.com/yzy0612/nltk_data.git  --branch gh-pages
  3. cd nltk_data
  4. mv packages/*  ./
  5. cd tokenizers
  6. unzip punkt.zip
  7. cd ../taggers
  8. unzip averaged_perceptron_tagger.zip

之后使用时服务器即会自动使用已有资源，无需再次下载。

二.数据准备

2.1 加载数据

得到所有目标文件路径之后，我们可以使用 LangChain 提供的 FileLoader 对象来加载目标文件，得到由目标文件解析出的纯文本内容。由于不同类型的文件需要对应不同的 FileLoader，我们判断目标文件类型，并针对性调用对应类型的 FileLoader，同时，调用 FileLoader 对象的 load 方法来得到加载之后的纯文本对象：

  1. from tqdm import tqdm
  2. from langchain.document_loaders import UnstructuredFileLoader
  3. from langchain.document_loaders import UnstructuredMarkdownLoader
  4.  
  5. def get_text(dir_path):
  6.     # args：dir_path，目标文件夹路径
  7.     # 首先调用上文定义的函数得到目标文件路径列表
  8.     file_lst = get_files(dir_path)
  9.     # docs 存放加载之后的纯文本对象
  10.     docs = []
  11.     # 遍历所有目标文件
  12.     for one_file in tqdm(file_lst):
  13.         file_type = one_file.split('.')[-1]
  14.         if file_type == 'md':
  15.             loader = UnstructuredMarkdownLoader(one_file)
  16.         elif file_type == 'txt':
  17.             loader = UnstructuredFileLoader(one_file)
  18.         else:
  19.             # 如果是不符合条件的文件，直接跳过
  20.             continue
  21.         docs.extend(loader.load())
  22.     return docs

使用上文函数，我们得到的 docs 为一个纯文本对象对应的列表。

2.2构建向量数据库

得到该列表之后，我们就可以将它引入到 LangChain 框架中构建向量数据库。由纯文本对象构建向量数据库，我们需要先对文本进行分块，接着对文本块进行向量化。

LangChain 提供了多种文本分块工具，此处我们使用字符串递归分割器，并选择分块大小为 500，块重叠长度为 150（由于篇幅限制，此处没有展示切割效果，学习者可以自行尝试一下，想要深入学习 LangChain 文本分块可以参考教程 《LangChain - Chat With Your Data》：

  1. from langchain.text_splitter import RecursiveCharacterTextSplitter
  2.  
  3. text_splitter = RecursiveCharacterTextSplitter(
  4.     chunk_size=500, chunk_overlap=150)
  5. split_docs = text_splitter.split_documents(docs)

接着我们选用开源词向量模型 Sentence Transformer 来进行文本向量化。LangChain 提供了直接引入 HuggingFace 开源社区中的模型进行向量化的接口：

  1. from langchain.embeddings.huggingface import HuggingFaceEmbeddings
  2.  
  3. embeddings = HuggingFaceEmbeddings(model_name="/root/data/model/sentence-transformer")

同时，考虑到 Chroma 是目前最常用的入门数据库，我们选择 Chroma 作为向量数据库，基于上文分块后的文档以及加载的开源向量化模型，将语料加载到指定路径下的向量数据库：

  1. from langchain.vectorstores import Chroma
  2.  
  3. # 定义持久化路径
  4. persist_directory = 'data_base/vector_db/chroma'
  5. # 加载数据库
  6. vectordb = Chroma.from_documents(
  7.     documents=split_docs,
  8.     embedding=embeddings,
  9.     persist_directory=persist_directory  # 允许我们将persist_directory目录保存到磁盘上
  10. )
  11. # 将加载的向量数据库持久化到磁盘上
  12. vectordb.persist()

三.InternLM 接入 Langchain

3.1 重写重写构造函数与 _call 函数

为便捷构建 LLM 应用，我们需要基于本地部署的 InternLM，继承 LangChain 的 LLM 类自定义一个 InternLM LLM 子类，从而实现将 InternLM 接入到 LangChain 框架中。完成 LangChain 的自定义 LLM 子类之后，可以以完全一致的方式调用 LangChain 的接口，而无需考虑底层模型调用的不一致。

基于本地部署的 InternLM 自定义 LLM 类并不复杂，我们只需从 LangChain.llms.base.LLM 类继承一个子类，并重写构造函数与 _call 函数即可：

  1. from langchain.llms.base import LLM
  2. from typing import Any, List, Optional
  3. from langchain.callbacks.manager import CallbackManagerForLLMRun
  4. from transformers import AutoTokenizer, AutoModelForCausalLM
  5. import torch
  6.  
  7. class InternLM_LLM(LLM):
  8.     # 基于本地 InternLM 自定义 LLM 类
  9.     tokenizer : AutoTokenizer = None
  10.     model: AutoModelForCausalLM = None
  11.  
  12.     def __init__(self, model_path :str):
  13.         # model_path: InternLM 模型路径
  14.         # 从本地初始化模型
  15.         super().__init__()
  16.         print("正在从本地加载模型...")
  17.         self.tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
  18.         self.model = AutoModelForCausalLM.from_pretrained(model_path, trust_remote_code=True).to(torch.bfloat16).cuda()
  19.         self.model = self.model.eval()
  20.         print("完成本地模型的加载")
  21.  
  22.     def _call(self, prompt : str, stop: Optional[List[str]] = None,
  23.                 run_manager: Optional[CallbackManagerForLLMRun] = None,
  24.                 **kwargs: Any):
  25.         # 重写调用函数
  26.         system_prompt = """You are an AI assistant whose name is InternLM (书生·浦语).
  27.         - InternLM (书生·浦语) is a conversational language model that is developed by Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless.
  28.         - InternLM (书生·浦语) can understand and communicate fluently in the language chosen by the user such as English and 中文.
  29.         """
  30.         
  31.         messages = [(system_prompt, '')]
  32.         response, history = self.model.chat(self.tokenizer, prompt , history=messages)
  33.         return response
  34.         
  35.     @property
  36.     def _llm_type(self) -> str:
  37.         return "InternLM"

在上述类定义中，我们分别重写了构造函数和 _call 函数：对于构造函数，我们在对象实例化的一开始加载本地部署的 InternLM 模型，从而避免每一次调用都需要重新加载模型带来的时间过长；_call 函数是 LLM 类的核心函数，LangChain 会调用该函数来调用 LLM，在该函数中，我们调用已实例化模型的 chat 方法，从而实现对模型的调用并返回调用结果。

在整体项目中，我们将上述代码封装为 LLM.py，后续将直接从该文件中引入自定义的 LLM 类。

3.2 构建检索问答链

LangChain 通过提供检索问答链对象来实现对于 RAG 全流程的封装。所谓检索问答链，即通过一个对象完成检索增强问答（即RAG）的全流程，针对 RAG 的更多概念，我们会在视频内容中讲解，也欢迎读者查阅该教程来进一步了解：《LLM Universe》。我们可以调用一个 LangChain 提供的 RetrievalQA 对象，通过初始化时填入已构建的数据库和自定义 LLM 作为参数，来简便地完成检索增强问答的全流程，LangChain 会自动完成基于用户提问进行检索、获取相关文档、拼接为合适的 Prompt 并交给 LLM 问答的全部流程。

3.3 加载向量数据库

首先我们需要将上文构建的向量数据库导入进来，我们可以直接通过 Chroma 以及上文定义的词向量模型来加载已构建的数据库：

  1. from langchain.vectorstores import Chroma
  2. from langchain.embeddings.huggingface import HuggingFaceEmbeddings
  3. import os
  4.  
  5. # 定义 Embeddings
  6. embeddings = HuggingFaceEmbeddings(model_name="/root/data/model/sentence-transformer")
  7.  
  8. # 向量数据库持久化路径
  9. persist_directory = 'data_base/vector_db/chroma'
  10.  
  11. # 加载数据库
  12. vectordb = Chroma(
  13.     persist_directory=persist_directory, 
  14.     embedding_function=embeddings
  15. )

上述代码得到的 vectordb 对象即为我们已构建的向量数据库对象，该对象可以针对用户的 query 进行语义向量检索，得到与用户提问相关的知识片段。

3.4 实例化自定义 LLM 与 Prompt Template

接着，我们实例化一个基于 InternLM 自定义的 LLM 对象：

from LLM import InternLM_LLM
llm = InternLM_LLM(model_path = "/root/data/model/Shanghai_AI_Laboratory/internlm-chat-7b")
llm.predict("你是谁")

构建检索问答链，还需要构建一个 Prompt Template，该 Template 其实基于一个带变量的字符串，在检索之后，LangChain 会将检索到的相关文档片段填入到 Template 的变量中，从而实现带知识的 Prompt 构建。我们可以基于 LangChain 的 Template 基类来实例化这样一个 Template 对象：

  1. from langchain.prompts import PromptTemplate
  2.  
  3. # 我们所构造的 Prompt 模板
  4. template = """使用以下上下文来回答用户的问题。如果你不知道答案，就说你不知道。总是使用中文回答。
  5. 问题: {question}
  6. 可参考的上下文：
  7. ···
  8. {context}
  9. ···
  10. 如果给定的上下文无法让你做出回答，请回答你不知道。
  11. 有用的回答:"""
  12.  
  13. # 调用 LangChain 的方法来实例化一个 Template 对象，该对象包含了 context 和 question 两个变量，在实际调用时，这两个变量会被检索到的文档片段和用户提问填充
  14. QA_CHAIN_PROMPT = PromptTemplate(input_variables=["context","question"],template=template)

3.5 构建检索问答链

最后，可以调用 LangChain 提供的检索问答链构造函数，基于我们的自定义 LLM、Prompt Template 和向量知识库来构建一个基于 InternLM 的检索问答链：

  1. from langchain.chains import RetrievalQA
  2.  
  3. qa_chain = RetrievalQA.from_chain_type(llm,retriever=vectordb.as_retriever(),return_source_documents=True,chain_type_kwargs={"prompt":QA_CHAIN_PROMPT})

得到的 qa_chain 对象即可以实现我们的核心功能，即基于 InternLM 模型的专业知识库助手。我们可以对比该检索问答链和纯 LLM 的问答效果：

  1. # 检索问答链回答效果
  2. question = "什么是InternLM"
  3. result = qa_chain({"query": question})
  4. print("检索问答链回答 question 的结果：")
  5. print(result["result"])
  6.  
  7. # 仅 LLM 回答效果
  8. result_2 = llm(question)
  9. print("大模型回答 question 的结果：")
  10. print(result_2)

四. 作业

4.1基础作业截图复现搭建小助手过程

1.环境搭建

2.数据向量库构建

3. 接入Langchain运行

4.2 进阶作业，自己搜集资料搭建垂直领域

1.数据准备

2.对比测试 

3.网页测试 

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

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号