FAISS创建知识库2

最新推荐文章于 2025-07-11 00:41:59 发布
最新推荐文章于 2025-07-11 00:41:59 发布
阅读量452 收藏 6
点赞数 4
CC 4.0 BY-SA版权
文章标签： faiss
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xnuscd/article/details/143300025

要在该代码中使用不同的嵌入模型（例如 m3e-base 或 bge-large），我们可以使代码更具通用性，将嵌入模型作为参数传递，以便能够动态加载任何支持的嵌入模型。此外，我们可以利用 sentence-transformers 或 transformers 库的预训练模型来生产嵌入。

以下是优化后的代码：

import faiss
import numpy as np
from transformers import AutoTokenizer, AutoModel
import torch

class VectorStore:
    def __init__(self, embedding_model: str, embedding_dim: int = 768, distance_metric: str = "l2"):
        """
        初始化向量存储，选择距离度量方式。
        :param embedding_model: 嵌入模型名称，例如 "m3e-base" 或 "bge-large"
        :param embedding_dim: 嵌入维度
        :param distance_metric: 距离度量方式，支持 "l2" (欧氏距离) 或 "ip" (内积)
        """
        self.tokenizer = AutoTokenizer.from_pretrained(embedding_model)
        self.model = AutoModel.from_pretrained(embedding_model)
        self.embedding_dim = embedding_dim
        
        # 根据距离度量方式初始化FAISS索引
        if distance_metric == "ip":
            self.index = faiss.IndexFlatIP(embedding_dim)  # 内积度量
        else:
            self.index = faiss.IndexFlatL2(embedding_dim)  # 默认为欧氏距离
        self.distance_metric = distance_metric

    def embed_text(self, texts: list) -> np.ndarray:
        """
        将文本列表转换为嵌入向量
        :param texts: 文本列表
        :return: 嵌入向量数组
        """
        inputs = self.tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
        with torch.no_grad():
            outputs = self.model(**inputs)
            embeddings = outputs.last_hidden_state[:, 0, :]  # 使用CLS向量
            embeddings = embeddings.cpu().numpy()  # 转为numpy数组

        if self.distance_metric == "l2":
            faiss.normalize_L2(embeddings)  # 如果是 L2，进行归一化

        return embeddings

    def add_documents(self, docs: list):
        """
        将文档列表添加到FAISS索引中
        """
        embeddings = self.embed_text(docs)
        self.index.add(np.array(embeddings, dtype=np.float32))  # 添加向量到索引
        self.docs = docs  # 保存文档内容以便打印

    def search(self, query: str, top_k: int = 5, score_threshold: float = 0.5):
        """
        在索引中搜索与查询最匹配的文档，并打印所有文档的相似度得分
        """
        print(f"\n查询内容: {query}")
        
        query_embedding = self.embed_text([query])  # 将查询转换为嵌入向量

        # 执行检索，获取所有文档的距离和索引
        distances, indices = self.index.search(query_embedding, len(self.docs))

        results = []
        print("\n所有文档的相似度得分：")
        for dist, idx in zip(distances[0], indices[0]):
            if self.distance_metric == "ip":
                score = dist  # 对于内积，分数直接是距离
                is_valid = score >= score_threshold  # 内积的分数是相似度，分数越高越相似
            else:
                score = 1 / (1 + dist)  # 欧氏距离转换为相似度分数
                is_valid = score >= score_threshold  # 欧氏距离的分数越低越相似
            
            # 打印所有文档的得分
            print(f"文档: {self.docs[idx]}, 相似度得分: {score}")
            
            if is_valid:
                results.append({'doc_index': idx, 'doc': self.docs[idx], 'score': score})

        print("\n匹配成功的文档（符合 score_threshold 的文档）：")
        for res in results:
            print(f"匹配文档索引: {res['doc_index']}, 内容: {res['doc']}, 匹配得分: {res['score']}")
        return results

    def save_index(self, file_path: str):
        """
        保存FAISS索引到文件
        """
        faiss.write_index(self.index, file_path)

    def load_index(self, file_path: str):
        """
        从文件加载FAISS索引
        """
        self.index = faiss.read_index(file_path)

# 使用示例
if __name__ == "__main__":
    docs = ["你好，这是一个样本文档。", "今天的天气很好。", "这是关于AI的介绍。", "机器学习是人工智能的一个分支。"]
    query = "什么是人工智能？"
    
    # 使用 "m3e-base" 嵌入模型初始化向量库
    vector_store = VectorStore(embedding_model="m3e-base", distance_metric="ip")

    # 添加文档
    vector_store.add_documents(docs)

    # 查询检索
    results = vector_store.search(query, top_k=3, score_threshold=0.5)

    # 保存索引
    vector_store.save_index("faiss_index.bin")
    
    # 加载索引
    # vector_store.load_index("faiss_index.bin")

代码改进说明

  1. 嵌入模型动态加载：

    • 使用 transformers 库，通过 embedding_model 参数传递模型名称，如 "m3e-base" 或 "bge-large" 等。
    • AutoTokenizer 和 AutoModel 动态加载嵌入模型，使得向量存储能够支持不同的嵌入模型。

  2. 嵌入生成方法：

    • embed_text 方法将输入文本列表转换为嵌入向量。这里使用 last_hidden_state[:, 0, :] 提取每个文本的 [CLS] 向量作为句子嵌入。
    • 对于 l2 度量，执行 L2 归一化，以便后续计算欧氏距离反映出相似度。

  3. add_documents 和 search：

    • add_documents 方法生成嵌入并添加到 FAISS 索引中，同时保存文档内容，便于在搜索时打印。
    • search 方法支持输出所有文档的相似度分数，并根据 score_threshold 筛选出匹配的文档。

  4. 使用示例：

    • 示例展示了如何使用 "m3e-base" 作为嵌入模型初始化向量存储库，并将文档添加到索引。
    • search 方法展示了与查询最匹配的文档及其相似度得分。
    • 还提供了将索引保存到文件和从文件加载索引的功能。

优化

为满足您的要求，我们可以将代码优化为同时打印以下内容：

  1. 查询内容 query。
  2. 所有文档与 query 的相似度分数（包括是否匹配成功）。
  3. 匹配成功的文档（满足 score_threshold）及其详细信息。

我们可以进一步简化 search 方法，使其能够一次性打印所有相似度信息并将匹配成功的文档筛选出来。以下是优化后的代码：

import faiss
import numpy as np
from transformers import AutoTokenizer, AutoModel
import torch

class VectorStore:
    def __init__(self, embedding_model: str, embedding_dim: int = 768, distance_metric: str = "l2"):
        """
        初始化向量存储，选择距离度量方式。
        :param embedding_model: 嵌入模型名称，例如 "m3e-base" 或 "bge-large"
        :param embedding_dim: 嵌入维度
        :param distance_metric: 距离度量方式，支持 "l2" (欧氏距离) 或 "ip" (内积)
        """
        self.tokenizer = AutoTokenizer.from_pretrained(embedding_model)
        self.model = AutoModel.from_pretrained(embedding_model)
        self.embedding_dim = embedding_dim
        
        # 根据距离度量方式初始化FAISS索引
        if distance_metric == "ip":
            self.index = faiss.IndexFlatIP(embedding_dim)  # 内积度量
        else:
            self.index = faiss.IndexFlatL2(embedding_dim)  # 默认为欧氏距离
        self.distance_metric = distance_metric

    def embed_text(self, texts: list) -> np.ndarray:
        """
        将文本列表转换为嵌入向量
        :param texts: 文本列表
        :return: 嵌入向量数组
        """
        inputs = self.tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
        with torch.no_grad():
            outputs = self.model(**inputs)
            embeddings = outputs.last_hidden_state[:, 0, :]  # 使用CLS向量
            embeddings = embeddings.cpu().numpy()  # 转为numpy数组

        if self.distance_metric == "l2":
            faiss.normalize_L2(embeddings)  # 如果是 L2，进行归一化

        return embeddings

    def add_documents(self, docs: list):
        """
        将文档列表添加到FAISS索引中
        """
        embeddings = self.embed_text(docs)
        self.index.add(np.array(embeddings, dtype=np.float32))  # 添加向量到索引
        self.docs = docs  # 保存文档内容以便打印

    def search(self, query: str, top_k: int = 5, score_threshold: float = 0.5):
        """
        在索引中搜索与查询最匹配的文档，并打印所有文档的相似度得分
        """
        print(f"\n查询内容: {query}")
        
        query_embedding = self.embed_text([query])  # 将查询转换为嵌入向量

        # 执行检索，获取所有文档的距离和索引
        distances, indices = self.index.search(query_embedding, len(self.docs))

        results = []
        print("\n所有文档的相似度得分：")
        for dist, idx in zip(distances[0], indices[0]):
            if self.distance_metric == "ip":
                score = dist  # 对于内积，分数直接是距离
                is_valid = score >= score_threshold  # 内积的分数是相似度，分数越高越相似
            else:
                score = 1 / (1 + dist)  # 欧氏距离转换为相似度分数
                is_valid = score >= score_threshold  # 欧氏距离的分数越低越相似
            
            # 打印所有文档的得分
            print(f"文档: {self.docs[idx]}, 相似度得分: {score}")
            
            if is_valid:
                results.append({'doc_index': idx, 'doc': self.docs[idx], 'score': score})

        print("\n匹配成功的文档（符合 score_threshold 的文档）：")
        for res in results:
            print(f"匹配文档索引: {res['doc_index']}, 内容: {res['doc']}, 匹配得分: {res['score']}")
        return results

    def save_index(self, file_path: str):
        """
        保存FAISS索引到文件
        """
        faiss.write_index(self.index, file_path)

    def load_index(self, file_path: str):
        """
        从文件加载FAISS索引
        """
        self.index = faiss.read_index(file_path)

# 使用示例
if __name__ == "__main__":
    docs = ["你好，这是一个样本文档。", "今天的天气很好。", "这是关于AI的介绍。", "机器学习是人工智能的一个分支。"]
    query = "什么是人工智能？"
    
    # 使用 "m3e-base" 嵌入模型初始化向量库
    vector_store = VectorStore(embedding_model="m3e-base", distance_metric="ip")

    # 添加文档
    vector_store.add_documents(docs)

    # 查询检索
    results = vector_store.search(query, top_k=3, score_threshold=0.5)

    # 保存索引
    vector_store.save_index("faiss_index.bin")
    
    # 加载索引
    # vector_store.load_index("faiss_index.bin")

优化细节说明

  1. 显示所有文档的相似度得分：

    • 在 search 方法中，我们对 distances 和 indices 进行迭代处理，计算出每个文档的相似度分数 score 并打印。
    • 这包括所有文档的得分，无论是否符合 score_threshold。

  2. 符合 score_threshold 的文档：

    • 在计算每个文档的 score 后，根据 distance_metric 判断相似性度量标准：
      • ip（内积）：直接使用距离作为相似度，分数越高越相似。
      • l2（欧氏距离）：将距离转换为相似度 score = 1 / (1 + dist)，分数越高越相似。
    • 对符合 score_threshold 的结果进行过滤，并将这些匹配成功的结果保存到 results 列表中，最后打印符合阈值的文档及其相似度得分。

  3. 更好的输出格式：

    • search 方法的输出格式被分为三部分：查询内容、所有文档的相似度得分、匹配成功的文档。

余弦相似度

上面的代码 并不是通过余弦相似度 来计算 query 和存储数据的相似度。代码中使用的是 欧氏距离 或 内积 作为相似度度量方式：

  1. 内积（Inner Product）：

    • 当 distance_metric="ip" 时，使用的是内积度量（点积），分数越高表示越相似。
    • 内积并不直接等同于余弦相似度，但在对向量进行单位化（归一化）处理后，内积可以近似为余弦相似度。

  2. 欧氏距离（L2 Distance）：

    • 当 distance_metric="l2" 时，使用的是欧氏距离度量，分数越低表示越相似。
    • 代码中将欧氏距离转换为相似度分数：score = 1 / (1 + dist)，但这也不是余弦相似度。

使用余弦相似度的优化方法

为了真正使用余弦相似度来计算 query 和存储数据的相似度，我们可以对向量进行 L2 归一化，然后使用内积度量。以下是基于余弦相似度的修改方法：

import faiss
import numpy as np
from transformers import AutoTokenizer, AutoModel
import torch

class VectorStore:
    def __init__(self, embedding_model: str, embedding_dim: int = 768):
        """
        初始化向量存储，并使用余弦相似度来计算相似度
        :param embedding_model: 嵌入模型名称，例如 "m3e-base" 或 "bge-large"
        :param embedding_dim: 嵌入维度
        """
        self.tokenizer = AutoTokenizer.from_pretrained(embedding_model)
        self.model = AutoModel.from_pretrained(embedding_model)
        self.embedding_dim = embedding_dim
        
        # 使用内积度量，并对嵌入进行归一化来模拟余弦相似度
        self.index = faiss.IndexFlatIP(embedding_dim)  # 内积度量

    def embed_text(self, texts: list) -> np.ndarray:
        """
        将文本列表转换为嵌入向量
        :param texts: 文本列表
        :return: 归一化后的嵌入向量数组
        """
        inputs = self.tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
        with torch.no_grad():
            outputs = self.model(**inputs)
            embeddings = outputs.last_hidden_state[:, 0, :]  # 使用CLS向量
            embeddings = embeddings.cpu().numpy()  # 转为numpy数组

        # 进行L2归一化，确保内积计算等效于余弦相似度
        faiss.normalize_L2(embeddings)
        return embeddings

    def add_documents(self, docs: list):
        """
        将文档列表添加到FAISS索引中
        """
        embeddings = self.embed_text(docs)
        self.index.add(np.array(embeddings, dtype=np.float32))  # 添加归一化后的向量到索引
        self.docs = docs  # 保存文档内容以便打印

    def search(self, query: str, top_k: int = 5, score_threshold: float = 0.5):
        """
        在索引中搜索与查询最匹配的文档，并打印所有文档的相似度得分
        """
        print(f"\n查询内容: {query}")
        
        query_embedding = self.embed_text([query])  # 将查询转换为归一化的嵌入向量

        # 执行检索，获取所有文档的内积（相似度）和索引
        distances, indices = self.index.search(query_embedding, len(self.docs))

        results = []
        print("\n所有文档的相似度得分（余弦相似度）：")
        for dist, idx in zip(distances[0], indices[0]):
            score = dist  # 由于使用归一化的向量，内积即为余弦相似度
            is_valid = score >= score_threshold
            
            # 打印所有文档的得分
            print(f"文档: {self.docs[idx]}, 相似度得分: {score}")
            
            if is_valid:
                results.append({'doc_index': idx, 'doc': self.docs[idx], 'score': score})

        print("\n匹配成功的文档（符合 score_threshold 的文档）：")
        for res in results:
            print(f"匹配文档索引: {res['doc_index']}, 内容: {res['doc']}, 匹配得分: {res['score']}")
        return results

    def save_index(self, file_path: str):
        """
        保存FAISS索引到文件
        """
        faiss.write_index(self.index, file_path)

    def load_index(self, file_path: str):
        """
        从文件加载FAISS索引
        """
        self.index = faiss.read_index(file_path)

# 使用示例
if __name__ == "__main__":
    docs = ["你好，这是一个样本文档。", "今天的天气很好。", "这是关于AI的介绍。", "机器学习是人工智能的一个分支。"]
    query = "什么是人工智能？"
    
    # 使用 "m3e-base" 嵌入模型初始化向量库
    vector_store = VectorStore(embedding_model="m3e-base")

    # 添加文档
    vector_store.add_documents(docs)

    # 查询检索
    results = vector_store.search(query, top_k=3, score_threshold=0.5)

    # 保存索引
    vector_store.save_index("faiss_index.bin")
    
    # 加载索引
    # vector_store.load_index("faiss_index.bin")

优化后的代码说明

  • 余弦相似度实现：通过 faiss.normalize_L2 对所有嵌入向量进行 L2 归一化，这样在计算内积时，结果就等同于余弦相似度。
  • 简化的相似度计算：使用内积直接作为余弦相似度的分数，打印和过滤过程都基于该分数。
  • 打印所有分数：在 search 方法中，打印所有文档的余弦相似度分数，同时筛选符合 score_threshold 的结果。

和工程代码相同

如果您的目标是确保相似度计算与之前工程代码相同，那么我们可以遵循以下方法：

  1. 确认与之前代码的距离度量方式一致：在您之前提供的代码片段中，similarity_search_with_score_by_vector 方法中使用了 内积（Inner Product） 和 欧氏距离（L2 Distance） 作为相似度度量方式，而并未指定使用余弦相似度。因此，我们将继续使用这两种度量方式，并通过模型归一化确保计算符合要求。

  2. 模型实现的归一化处理：根据之前工程代码的逻辑，可以通过对查询和嵌入向量的归一化来确保一致性。对于 distance_strategy 为 l2 时，归一化后的内积可以等效于余弦相似度，而对于 ip 时直接使用内积。

下面是确保与之前工程代码一致的改进代码：

import faiss
import numpy as np
from transformers import AutoTokenizer, AutoModel
import torch

class VectorStore:
    def __init__(self, embedding_model: str, embedding_dim: int = 768, distance_metric: str = "l2"):
        """
        初始化向量存储，选择距离度量方式。
        :param embedding_model: 嵌入模型名称，例如 "m3e-base" 或 "bge-large"
        :param embedding_dim: 嵌入维度
        :param distance_metric: 距离度量方式，支持 "l2" (欧氏距离) 或 "ip" (内积)
        """
        self.tokenizer = AutoTokenizer.from_pretrained(embedding_model)
        self.model = AutoModel.from_pretrained(embedding_model)
        self.embedding_dim = embedding_dim
        
        # 初始化FAISS索引
        if distance_metric == "ip":
            self.index = faiss.IndexFlatIP(embedding_dim)  # 内积度量
        else:
            self.index = faiss.IndexFlatL2(embedding_dim)  # 默认为欧氏距离
        self.distance_metric = distance_metric

    def embed_text(self, texts: list) -> np.ndarray:
        """
        将文本列表转换为嵌入向量
        :param texts: 文本列表
        :return: 嵌入向量数组
        """
        inputs = self.tokenizer(texts, padding=True, truncation=True, return_tensors="pt")
        with torch.no_grad():
            outputs = self.model(**inputs)
            embeddings = outputs.last_hidden_state[:, 0, :]  # 使用CLS向量
            embeddings = embeddings.cpu().numpy()  # 转为numpy数组

        # 根据距离度量方式，选择是否进行L2归一化
        if self.distance_metric == "l2":
            faiss.normalize_L2(embeddings)  # 如果是 L2，进行归一化
        return embeddings

    def add_documents(self, docs: list):
        """
        将文档列表添加到FAISS索引中
        """
        embeddings = self.embed_text(docs)
        self.index.add(np.array(embeddings, dtype=np.float32))  # 添加向量到索引
        self.docs = docs  # 保存文档内容以便打印

    def search(self, query: str, top_k: int = 5, score_threshold: float = 0.5):
        """
        在索引中搜索与查询最匹配的文档，并打印所有文档的相似度得分
        """
        print(f"\n查询内容: {query}")
        
        query_embedding = self.embed_text([query])  # 将查询转换为嵌入向量

        # 执行检索，获取所有文档的距离和索引
        distances, indices = self.index.search(query_embedding, len(self.docs))

        results = []
        print("\n所有文档的相似度得分：")
        for dist, idx in zip(distances[0], indices[0]):
            if self.distance_metric == "ip":
                score = dist  # 对于内积，分数直接是距离
                is_valid = score >= score_threshold  # 内积的分数是相似度，分数越高越相似
            else:
                score = 1 / (1 + dist)  # 欧氏距离转换为相似度分数
                is_valid = score >= score_threshold  # 欧氏距离的分数越低越相似
            
            # 打印所有文档的得分
            print(f"文档: {self.docs[idx]}, 相似度得分: {score}")
            
            if is_valid:
                results.append({'doc_index': idx, 'doc': self.docs[idx], 'score': score})

        print("\n匹配成功的文档（符合 score_threshold 的文档）：")
        for res in results:
            print(f"匹配文档索引: {res['doc_index']}, 内容: {res['doc']}, 匹配得分: {res['score']}")
        return results

    def save_index(self, file_path: str):
        """
        保存FAISS索引到文件
        """
        faiss.write_index(self.index, file_path)

    def load_index(self, file_path: str):
        """
        从文件加载FAISS索引
        """
        self.index = faiss.read_index(file_path)

# 使用示例
if __name__ == "__main__":
    docs = ["你好，这是一个样本文档。", "今天的天气很好。", "这是关于AI的介绍。", "机器学习是人工智能的一个分支。"]
    query = "什么是人工智能？"
    
    # 使用 "m3e-base" 嵌入模型初始化向量库
    vector_store = VectorStore(embedding_model="m3e-base", distance_metric="ip")

    # 添加文档
    vector_store.add_documents(docs)

    # 查询检索
    results = vector_store.search(query, top_k=3, score_threshold=0.5)

    # 保存索引
    vector_store.save_index("faiss_index.bin")
    
    # 加载索引
    # vector_store.load_index("faiss_index.bin")

代码优化说明

  • 相似度度量方式的一致性：distance_metric 参数允许在 内积 和 欧氏距离 间切换，以与之前代码中的相似度度量方式保持一致。
  • L2 归一化：
    • 如果使用欧氏距离（l2），在 embed_text 方法中对嵌入向量执行 L2 归一化，这与之前代码中将 l2 转换为相似度的处理方式一致。
    • 对于内积（ip），则无需归一化，直接使用距离作为相似度分数。
  • 打印和过滤：
    • 在 search 方法中，所有文档的相似度分数都将打印，并且符合 score_threshold 的结果会被过滤并输出。
xnuscd
关注
知识库的创建（5） - FaissKBService
一起来研究langchain和langchain-chatchat
06-20 1234
上一篇文章，我们追到了这里，了解了kb是通过KBServiceFactory产生的一个对象，而且这个对象根据类型不同，分别会实例化出类似 FaissKBService和ChromaKBService这样的向量数据库对象。之前在向量索引的文章里，我们讲过Faiss和Chroma这两种向量数据库，并且简易写了运用他们的代码。今天我们看看langchain-chatchat是 怎么封装的self,kb_name: 知识库的名称，是一个必需的字符串参数。: 向量存储的名称，是一个可选字符串参数。
Python 向量检索库Faiss使用
m0_65482549的博客
12-29 1907
Faiss（Facebook AI Similarity Search）是一个由 Facebook AI Research 开发的库，它专门用于高效地搜索和聚类大量向量。Faiss 能够在几毫秒内搜索数亿个向量，这使得它非常适合于实现近似最近邻（ANN）搜索，这在许多应用中都非常有用，比如图像检索、推荐系统和自然语言处理。
FAISS知识库创建
xnuscd的博客
10-28 749
在方法中，定义了文档的最低相似度要求或最高允许距离。
FAISS：高性能向量库
专注最新最热的AI知识学习，以实战方式总结心得。
06-09 862
(Facebook AI Similarity Search) 是一个专门用于的开源库。
Github 15K！ 亿级向量相似度检索库Faiss 原理+应用
Kaiyuan_sjtu的博客
11-25 8830
作者|Chilia整理|NewBeeNLP最近在使用ColBERT双塔结构进行文本召回，其中必然要涉及到向量相似度查询，如果只用brute-force方法的复杂度实在太高，...
1.FAISS与Langchain整合，搭配大模型实现本地知识库问答
daohangtaiqian的博客
12-26 1127
{‘query’: ‘我有想做系统有400万辆车，帮我出一个架构’, ‘result’: ‘根据您提供的信息，针对拥有400万辆车的系统，建议采用与“系统2”相似的架构。以下是推荐的系统架构配置：\n\n### 系统架构配置：\n-
Faiss 简介
weixin_39663060的博客
05-30 1212
最近在做知识库问答的时候看到了Faiss，查询了一些资料了解其原理，下面做简单记录，方便以后查阅。(Facebook AI Similarity Search)是Facebook AI团队开源的针对聚类和相似性搜索库，为稠密向量提供高效相似度搜索和聚类，支持十亿级别向量的搜索，是目前较成熟的近似近邻搜索库。Faiss整体流程图如下所示：图中，Faiss主要包含两个步骤：Faiss训练和Faiss查询。
【DeepSeek知识库】Python使用faiss进行知识库文本搭建【效果不好，只是思路】
06-09
尽管文档中提到最终搭建的效果并不理想，但是其介绍的使用Python和faiss库搭建本地知识库的基本思路和方法，对于希望在本地环境下搭建知识库的开发者来说，提供了重要的参考。通过合理的数据预处理、高效的索引创建...
使用GPT3.5,LangChain，FAISS和python构建一个本地知识库
weixin_43589681的博客
07-16 1816
现在的一个简单理解是，FAISS并不能直接存储数据，它只是一个索引和搜索向量的工具，这个工具可以根据emdebbing的后生成的向量，从文本中匹配跟问题相关的内容出来。所以我们设计的时候应该得分成两步进行设计，一部分是生成本地文件的代码，一部分是加载本地文件的代码，当然加载本地文件就是直接写在业务代码里面，不需要单独拆出来了。LangChain则是对大语言模型技术所用到的一些功能进行了统一的封装，这使得我们可以利用本地的知识资源，以获得我们需要的信息，FAISS则是一个可以存储这种类型数据的向量数据库。
【FAISS助力基于本地DeepSeek构建管理个性化知识库：从原理到实战详解】
最新发布
在记录自己编程工作与编程生活的同时，给那些困于无法入门编程世界的朋友提供一点帮助，在有限的生命中给有需要的人尽一点绵薄之力。
07-11 298
本文介绍了基于FAISS向量数据库和DeepSeek模型的个性化知识库构建方案。系统采用多格式文档解析、智能文本分块和语义向量化技术，通过FAISS的高效索引结构（IVF+PQ）实现快速检索。架构包含文件处理、文本分块、向量化、FAISS存储和元数据管理等核心模块，支持多用户隔离和增量更新。方案利用sentence-transformers生成384维向量，结合倒排列表和乘积量化技术，在保证精度的同时提升检索效率100倍以上。系统支持PDF/DOCX/TXT等格式，提供ID查询和语义搜索双模式，适用于个人知
AI大模型之旅-langchain结合glm4,faiss构建本地知识库
weixin_43866043的博客
09-20 709
问题1：(ckglm4) ck@insight:~/PycharmProjects/ckpractice$ pip install faiss-gpu。答案：使用conda安装。
FaissPQ索引简介
Maisucsdn的博客
09-29 301
在faiss的乘积量化的实现中，还引入了层次化量化的思想，在乘积量化前引入了一层粗糙量化，形成粗糙量化+细粒度量化的两层结构。其中,||x_r||^2+2x_cx_r∣∣xr​∣∣2+2xc​xr​和y无关，可以预先计算缓存，||y-x_c||^2∣∣y−xc​∣∣2部分需要计算查询向量yy到粗糙聚类中心的距离，这部分的计算量取决于训练时设定的粗糙聚类中心个数，2yx_r2yxr​部分需要计算查询向量和簇内残差向量，这部分计算量和设定的查询类簇数量相关，最坏情况下需要遍历所有类簇。
LangChain学习一：模型-实战
huiguo_的博客
12-06 2264
聊天模型：这些模型通常由语言模型支持，但它们的API更加结构化。具体来说，这些模型将聊天消息列表作为输入，并返回聊天消息。这里的content就相当于大模型机器回答，干啥用呢，为了以后的多轮对话做准备。LLMs：这些模型将文本字符串作为输入，并返回文本字符串作为输出。还可有以下情况，就是上面说的模仿大模型说话，我们先看一下原生的。文本嵌入模型：这些模型将文本作为输入，并返回一个浮点数列表。看到没，这时候，我们的大模型就可以作为一个助手帮你了。LangChain 支持的各种模型类型和模型集成。
基于m3e编码模型的RAG 向量相似检索
jieshenai的博客
03-19 1252
使用m3e编码模型，利用modelscope下载模型权重。使用langchain的faiss API ，构建向量库，计算用户输入文本与向量库中文本的相似度。
相似向量检索库-Faiss-简介及原理
热门推荐
Catcher
01-15 3万+
前言 由于项目需要，需要对某些种子用户进行look-alike，找到相似用户，所以近期对相似向量检索库Faiss进行一定的了解，接下来，结合相关资料，把我对这个库的了解记录在这里，也希望对你有所帮助！ 一：Faiss简介 Faiss全称(Facebook AI Similarity Search)是Facebook AI团队开源的针对聚类和相似性搜索库，为稠密向量提供高效相似度搜索和聚类，支持十亿级别向量的搜索，是目前较成熟的近似近邻搜索库。 它包含多种搜索任意大小向量集（备注：向量集大小由RAM内存决定）
Faiss简单使用
HJ_blog
07-18 2357
在本节中使用的索引类型不需要训练，大家可以使用IndexIVFFlat（倒排索引）试试，倒排索引需要进行索引训练，而且检索效率更高。
基于 Langchain 和 FAISS 构建 LLM 知识库
ove_z的博客
09-17 1918
使用 Langchain 和 FAISS 来一步一步构建一个（相对）高效的知识库系统
向量数据库 Faiss 的实践与增强探索
易迟的专栏
05-18 2199
在构建大模型知识库，即检索增强生成 (RAG) 服务时，中间存在一个核心环节就是向量化搜索，如果不希望引入第三方的向量数据库，那么开源的 Faiss 就是一个不错的选择。Faiss 是 FaceBook 提供的开源向量库搜索库，在Github上已经有 28.1k star，相对成熟而且使用方便。之前构建的 RAG 服务使用的就是 Faiss 提供的向量化搜索服务，Faiss 功能强大，上手简单。但是在实际产品化的过程中发现了不少不足，在实践过程中进行了必要的迭代增强，本文就是对这个过程的记录。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值