释放本地 Rag 的力量：与 Deepseek R1 和 Ollama 深入探讨！

使用您的数据构建本地 RAG

介绍

在本文中，我们将探讨如何使用您自己的数据构建本地 RAG (Retrieval-Augmented Generation) 模型。这种方法允许您定制模型，以更好地适应您的特定用例。

先决条件

在开始之前，请确保您具备以下条件：

• Python 3.7 或更高版本
• 访问您的数据集
• 对机器学习概念的基本理解

构建本地 RAG 的步骤

1. 设置您的环境

   首先，您需要设置您的 Python 环境。您可以使用 venv 或 conda 来实现这一目的。

   python -m venv rag-env
   source rag-env/bin/activate  # 在 Windows 上使用 `rag-env\Scripts\activate`
   

2. 安装所需库

   使用 pip 安装必要的库：

   pip install transformers datasets faiss-cpu
   

3. 加载您的数据集

   将您的数据集加载到 Python 脚本中。例如，如果您有一个 CSV 文件：

   import pandas as pd
   
   data = pd.read_csv('your_dataset.csv')
   

4. 预处理数据

   根据需要预处理您的数据。这可能包括清理文本、标记化等。

   from transformers import AutoTokenizer
   
   tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
   tokens = tokenizer(data['text_column'].tolist(), padding=True, truncation=True, return_tensors='pt')
   

5. 构建 RAG 模型

   使用 Hugging Face Transformers 库构建 RAG 模型。

   from transformers import RagTokenizer, RagRetriever, RagSequenceForGeneration
   
   rag_tokenizer = RagTokenizer.from_pretrained('facebook/rag-sequence')
   rag_retriever = RagRetriever.from_pretrained('facebook/rag-sequence', index_name="custom", passages=data['text_column'].tolist())
   rag_model = RagSequenceForGeneration.from_pretrained('facebook/rag-sequence')
   

6. 训练模型

   使用您的数据集训练 RAG 模型。确保定义您的训练循环和优化策略。

   from transformers import Trainer, TrainingArguments
   
   training_args = TrainingArguments(
       output_dir='./results',
       num_train_epochs=3,
       per_device_train_batch_size=16,
       save_steps=10_000,
       save_total_limit=2,
   )
   
   trainer = Trainer(
       model=rag_model,
       args=training_args,
       train_dataset=your_train_dataset,
   )
   
   trainer.train()
   

结论

使用您自己的数据构建本地 RAG 模型可以显著提高其在特定任务中的性能。通过遵循上述步骤，您可以定制模型以更好地满足您的需求。

参考文献

• Hugging Face Transformers 文档
• 关于 RAG 模型的研究论文

这篇关于使用您的数据构建本地 RAG 的文章到此结束。

使用 DeepSeek R1 和 Ollama 构建强大的 RAG 系统

DeepSeek R1 和 Ollama 提供强大的工具用于构建 Retrieval-Augmented Generation (RAG) 系统。本指南涵盖了使用这些技术开发 RAG 应用程序的设置、实施和最佳实践。

为什么RAG系统是游戏规则的改变者

Retrieval-augmented generation (RAG)系统结合了搜索和generative AI的最佳特性，使得响应能够考虑上下文，既精确又准确。借助像DeepSeek R1和Ollama这样的工具，创建一个RAG系统不再令人生畏。无论您是在构建聊天机器人、知识助手，还是一个AI驱动的搜索引擎，本指南为您提供了所需了解的一切。

Prerequisites

• Python 3.10+
• Ollama installed locally

您将学习的内容

• 设置 DeepSeek R1 和 Ollama 以实现 RAG。
• 实现文档处理、向量存储和查询管道。
• 优化性能、相关性和用户体验。

构建 RAG 管道的步骤

1. 设置环境和导入库

确保您已安装所需的 Python 包。您可以使用以下命令安装它们：

pip install langchain-core langchain-community langchain-ollama langchain-huggingface faiss-cpu psutil

• 导入库

from typing import List
from langchain_core.documents import Document
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_huggingface import HuggingFaceEmbeddings
from langchain_ollama.llms import OllamaLLM
from langchain_community.vectorstores import FAISS
import logging
import psutil
import os

2. 初始化 RAGPipeline 类

RAGPipeline 类管理整个过程，包括内存监控、文档加载、嵌入生成和查询模型。

class RAGPipeline:
    def __init__(self, model_name: str = "llama2:7b-chat-q4", max_memory_gb: float = 3.0):
        self.setup_logging()
        self.check_system_memory(max_memory_gb)

        self.llm = OllamaLLM(model="deepseek-r1:8b")

        self.embeddings = HuggingFaceEmbeddings(
            model_name="sentence-transformers/all-mpnet-base-v2",
            model_kwargs={'device': 'cpu'}  
        )

        self.prompt = ChatPromptTemplate.from_template("""
            Answer the question based only on the following context. Be concise.
            If you cannot find the answer in the context, say "I cannot answer this based on the provided context."

            Context: {context}
            Question: {question}
            Answer: """)

3. 内存管理和日志记录

为了防止在低内存环境中崩溃，我们在执行之前记录并检查可用内存。

def setup_logging(self):
    logging.basicConfig(level=logging.INFO)
    self.logger = logging.getLogger(__name__)

def check_system_memory(self, max_memory_gb: float):
    available_memory = psutil.virtual_memory().available / (1024 ** 3)
    self.logger.info(f"Available system memory: {available_memory:.1f} GB")
    if available_memory < max_memory_gb:
        self.logger.warning("Memory is below recommended threshold.")

4. 加载和拆分文档

我们使用 TextLoader 和 RecursiveCharacterTextSplitter 来高效处理文档。

def load_and_split_documents(self, file_path: str) -> List[Document]:
    loader = TextLoader(file_path)
    documents = loader.load()

    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=50,
        length_function=len,
        add_start_index=True,
    )
    splits = text_splitter.split_documents(documents)
    self.logger.info(f"Created {len(splits)} document chunks")
    return splits

5. 使用 FAISS 创建向量存储

我们使用 FAISS 进行高效的文档检索，并以较小的批次处理文档。

def create_vectorstore(self, documents: List[Document]) -> FAISS:
    batch_size = 32
    vectorstore = FAISS.from_documents(documents[:batch_size], self.embeddings)

    for i in range(batch_size, len(documents), batch_size):
        batch = documents[i:i + batch_size]
        vectorstore.add_documents(batch)
        self.logger.info(f"Processed batch {i//batch_size + 1}")
    
    return vectorstore

6. 设置 RAG 链

我们定义检索机制以高效获取相关文档。

def setup_rag_chain(self, vectorstore: FAISS):
    retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 2, "fetch_k": 3})

def format_docs(docs):
    return "\\n\\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | self.prompt
    | self.llm
    | StrOutputParser()
)
return rag_chain

7. 查询带有内存监控的模型

我们在执行查询之前记录内存使用情况。

def query(self, chain, question: str) -> str:
    memory_usage = psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024
    self.logger.info(f"Memory usage: {memory_usage:.1f} MB")
    return chain.invoke(question)

8. 整合所有内容

我们初始化 RAG 管道，处理文档，并运行一个示例查询。

def main():
    rag = RAGPipeline(model_name="deepseek-r1:8b", max_memory_gb=3.0)

    documents = rag.load_and_split_documents("data/knowledge.txt")
    vectorstore = rag.create_vectorstore(documents)
    chain = rag.setup_rag_chain(vectorstore)

    question = "What is AI?"
    response = rag.query(chain, question)
    print(f"Question: {question}\\nAnswer: {response}")

if __name__ == "__main__":
    main()

结论

本博客详细介绍了如何使用 LangChain、Ollama、FAISS 和 Hugging Face embeddings 构建一个内存高效的 RAG pipeline。通过优化文档分块、向量存储和内存监控，这种方法确保即使在资源有限的环境中也能实现高效的 AI 驱动文档检索。

参考文献