当前位置:   article > 正文

第26篇:深入剖析:LangChain的本地向量化模型应用_langchain 向量化

langchain 向量化

大家好,今天我们将通过一个简单的应用示例,介绍如何使用LangChain库和本地向量化模型完成从文本文件加载到向量化处理、存储到向量库,并根据提示语进行向量检索的全过程。本文将详细介绍每一步的实现,包括使用Loader加载文本文件、生成Document文档、使用Text Splitters进行文本分割、使用本地向量化模型进行向量化处理、将向量保存到Chroma向量库,并根据提示语进行向量检索。本文将提供详细的代码实现和注释,并使用流程图展示流程。

安装依赖包

在开始之前,我们需要安装LangChain库和其他相关的依赖包:

pip install langchain transformers torch chromadb
  • 1

项目的流程

我们将按照以下步骤实现这个项目:

  1. 使用Loader加载器加载外部目录的文本文件。
  2. 生成Document文档。
  3. 使用Text Splitters进行文本分割。
  4. 使用本地向量化模型进行向量化处理(举例使用bge-base-zh-v1.5模型和百川2模型)。
  5. 将向量保存到Chroma向量库。
  6. 根据提示语进行向量检索。

流程图

首先,我们使用流程图展示整个流程:

加载文本文件
生成Document文档
文本分割
向量化处理
保存到向量库
向量检索

实现步骤

1. 使用Loader加载器加载文本文件

我们首先使用Loader加载器从外部目录加载文本文件。假设我们有一个目录包含多个文本文件。

import os
from langchain.loaders import SimpleLoader

def load_text_files(directory_path):
    """
    从指定目录加载所有文本文件
    :param directory_path: 文本文件所在的目录路径
    :return: 文本文件内容列表
    """
    loader = SimpleLoader(directory_path=directory_path)
    text_files = loader.load()
    return text_files

# 使用示例
directory_path = 'path/to/text/files'
text_files = load_text_files(directory_path)
print(f"成功加载 {len(text_files)} 个文件")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

2. 生成Document文档

接下来,我们将加载的文本内容生成Document文档。Document是LangChain库中用于表示文本数据的核心数据结构。

from langchain.documents import Document

def create_documents(text_files):
    """
    生成Document文档
    :param text_files: 文本文件内容列表
    :return: Document文档列表
    """
    documents = [Document(content=text) for text in text_files]
    return documents

# 使用示例
documents = create_documents(text_files)
print(f"成功生成 {len(documents)} 个Document文档")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

3. 使用Text Splitters进行文本分割

为了更好地处理和向量化文本数据,我们需要将长文本分割成更小的段落。我们使用Text Splitters工具来实现这一点。

from langchain.text_splitters import SimpleTextSplitter

def split_documents(documents, chunk_size=512, chunk_overlap=50):
    """
    分割Document文档
    :param documents: Document文档列表
    :param chunk_size: 每个分割段的最大字符数
    :param chunk_overlap: 分割段之间的重叠字符数
    :return: 分割后的Document文档列表
    """
    splitter = SimpleTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
    split_documents = []
    for doc in documents:
        split_documents.extend(splitter.split(doc))
    return split_documents

# 使用示例
split_docs = split_documents(documents)
print(f"成功分割为 {len(split_docs)} 个Document段落")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

4. 使用本地向量化模型进行向量化处理

我们将分别使用两个本地向量化模型:bge-base-zh-v1.5和百川2模型进行向量化处理。

bge-base-zh-v1.5模型
from transformers import AutoModel, AutoTokenizer
import torch

class LocalEmbedder:
    def __init__(self, model_name):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModel.from_pretrained(model_name)
        
    def embed(self, text):
        """
        使用本地模型对文本进行向量化处理
        :param text: 输入文本
        :return: 文本的嵌入向量
        """
        inputs = self.tokenizer(text, return_tensors='pt')
        outputs = self.model(**inputs)
        return outputs.last_hidden_state.mean(dim=1).detach().numpy()

# 使用示例
bge_model = LocalEmbedder("bge-base-zh-v1.5")
bge_embeddings = [bge_model.embed(doc.content) for doc in split_docs]
print(f"成功生成 {len(bge_embeddings)} 个嵌入向量(bge-base-zh-v1.5)")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
百川2模型
class BaichuanEmbedder:
    def __init__(self, model_name):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModel.from_pretrained(model_name)
        
    def embed(self, text):
        """
        使用百川2模型对文本进行向量化处理
        :param text: 输入文本
        :return: 文本的嵌入向量
        """
        inputs = self.tokenizer(text, return_tensors='pt')
        outputs = self.model(**inputs)
        return outputs.last_hidden_state.mean(dim=1).detach().numpy()

# 使用示例
baichuan_model = BaichuanEmbedder("baichuan2")
baichuan_embeddings = [baichuan_model.embed(doc.content) for doc in split_docs]
print(f"成功生成 {len(baichuan_embeddings)} 个嵌入向量(百川2)")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

5. 将向量保存到Chroma向量库

我们将生成的向量保存到Chroma向量库中,以便后续进行检索和分析。

from chromadb import ChromaClient

def save_to_chroma(embeddings, documents, collection_name="text_embeddings"):
    """
    将向量保存到Chroma向量库
    :param embeddings: 嵌入向量列表
    :param documents: 分割后的Document文档列表
    :param collection_name: 向量库集合名称
    """
    client = ChromaClient()
    collection = client.get_or_create_collection(collection_name)
    
    for doc, embedding in zip(documents, embeddings):
        collection.add(embedding=embedding, metadata={"content": doc.content})
    
    print(f"成功保存 {len(embeddings)} 个嵌入向量到Chroma向量库中")

# 使用示例
save_to_chroma(bge_embeddings, split_docs, collection_name="bge_embeddings")
save_to_chroma(baichuan_embeddings, split_docs, collection_name="baichuan_embeddings")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

6. 根据提示语进行向量检索

最后,我们使用Chroma向量库进行向量检索,根据提示语查询相关的文本内容。

def query_chroma(query, model, collection_name="text_embeddings", top_k=5):
    """
    根据提示语进行向量检索
    :param query: 查询提示语
    :param model: 向量化模型
    :param collection_name: 向量库集合名称
    :param top_k: 返回的最相关文本数量
    :return: 最相关的文本内容列表
    """
    client = ChromaClient()
    collection = client.get_collection(collection_name)
    query_vector = model.embed(query)
    results = collection.query(query_vector=query_vector, top_k=top_k)
    
    return [result['metadata']['content'] for result in results]

# 使用示例
query_text = "智能手表的主要特点"
bge_retrieved_texts = query_chroma(query_text, bge_model, collection_name="bge_embeddings")
baichuan_retrieved_texts = query_chroma(query_text, baichuan_model, collection_name="baichuan_embeddings")

print("bge-base-zh-v1.5模型查询结果:")
for i, text in enumerate(bge_retrieved_texts):
    print(f"{i + 1}: {text}")

print("百川2模型查询结果:")
for i, text in enumerate(baichuan_retrieved_texts):
    print(f"{i + 1}: {text}")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

总结

通过这篇博客,我们详细介绍了如何使用LangChain库完成从文本文件加载到向量化处理、存储到向量库,并根据提示语进行向量检索的全过程。以下是我们所讲解的关键步骤:

  1. 加载文本文件:使用Loader加载器从外部目录加载文本文件。
  2. 生成Document文档:将加载的文本内容生成Document文档。
  3. 文本分割:使用Text Splitters工具将长文本分割成更小的段落。
  4. 向量化处理:分别使用bge-base-zh-v1.5模型和百川2模型对分割后的文本进行向量化处理。
  5. 保存到向量库:将生成的向量保存到Chroma向量库中。
  6. 向量检索:根据提示语进行向量检索,查询相关的文本内容。

如果你喜欢这篇文章,别忘了收藏文章、关注作者、订阅专栏,感激不尽。

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

闽ICP备14008679号