RAG与LoRA技术融合：构建希腊语多领域专家模型的实战指南

在实际的自然语言处理项目中，我们常常面临一个核心挑战：如何让一个通用的大语言模型（LLM）精通一门特定语言（如希腊语）并深入理解多个专业领域（如法律、医学、科技）的术语和知识。直接使用通用模型，其回答往往流于表面，缺乏深度和准确性；而从头训练一个领域专用模型，则成本高昂，数据获取困难。近年来，检索增强生成（RAG）与参数高效微调（如LoRA）技术的结合，为这一难题提供了极具前景的解决方案。本文将以“Teaching Nemotron Greek”这一虚构但典型的技术目标为例，系统性地拆解如何为一个现代希腊语多领域专家模型构建技术栈。我们将从零开始，完整走过语料库挖掘、检索系统适配、生成模型增强以及最终的工程化部署与评估流程。无论你是希望构建垂直领域知识问答系统，还是需要将LLM能力适配到新的语言或专业场景，本文提供的从数据到评估的实战路径都将为你提供清晰的指引。

1. 理解核心概念：RAG与LoRA如何协同工作

在开始动手之前，必须厘清RAG（Retrieval-Augmented Generation）和LoRA（Low-Rank Adaptation）这两个核心技术的定位、原理以及它们如何互补，这是设计整个项目架构的基础。

1.1 RAG：为模型注入外部知识库

RAG的核心思想是“按需取用，增强回答”。它不直接修改模型内部的参数，而是在模型生成答案时，动态地从外部知识库中检索最相关的文档片段，并将其作为上下文提供给模型，从而引导模型生成更准确、信息更丰富的回答。

工作流程通常分为三步：

1. 索引（Indexing）：将原始文档（如希腊语法律条文、医学论文）进行切分、向量化，并存入向量数据库。
2. 检索（Retrieval）：当用户提出一个问题（Query）时，将其向量化，并在向量数据库中查找语义最相似的文档片段。
3. 生成（Generation）：将检索到的相关片段（Context）和原始问题一起，组合成一个增强的提示（Prompt），输入给LLM，让其基于此生成最终答案。

RAG的优势在于知识更新成本低（只需更新向量数据库）、可解释性强（答案来源于检索到的文档），并且能有效缓解模型的“幻觉”问题。但它依赖于检索的质量，如果检索不到或检索错误，生成结果也会出错。

1.2 LoRA：高效微调模型内部能力

与RAG的外部增强不同，LoRA是一种参数高效微调（PEFT）技术，旨在用极小的训练成本，轻微调整模型本身的行为。其原理是在预训练模型原有的权重矩阵旁，添加一个低秩分解的适配器（Adapter）。在微调时，只训练这些新增的、参数量极小的适配器权重，而冻结原始庞大的模型权重。

LoRA的核心价值体现在：

• 高效：训练参数量仅为全量微调的0.1%-1%，大大节省计算资源和时间。
• 轻量：训练得到的适配器权重文件很小（通常几十到几百MB），易于存储和分发。
• 可组合：可以为不同任务训练不同的LoRA适配器，并在推理时灵活切换。

在“Teaching Nemotron Greek”的场景中，LoRA微调的目标是让模型更好地“理解”现代希腊语的语法、句法习惯，以及初步感知专业领域的语言风格，而不是记住所有具体知识。知识本身交给RAG负责。

1.3 RAG + LoRA 的协同架构

两者结合，形成了分层的能力增强架构：

• LoRA层（底层能力适配）：负责提升模型对目标语言（希腊语）和领域文本风格的底层理解与生成能力。例如，让模型更擅长用希腊语组织句子，更熟悉法律文书或医学报告的写作范式。
• RAG层（上层知识注入）：负责为模型提供具体、实时、海量的领域知识。当模型需要回答一个具体的法律条款解释或医学案例时，RAG从知识库中提取精确的条文或论文片段。

这种架构既保证了模型对语言和领域的基本掌握（通过LoRA），又确保了回答的事实准确性（通过RAG），同时保持了系统的灵活性和可维护性。

2. 环境准备与项目结构规划

在开始编码和训练前，搭建一个清晰、可复现的环境是成功的第一步。

2.1 硬件与软件环境要求

2.2 核心依赖库安装

创建一个新的Python虚拟环境，并安装以下核心包。版本号是写作时的常见选择，实际落地前请根据官方文档确认兼容性。

# 创建并激活虚拟环境 conda create -n nemotron-greek python=3.10 conda activate nemotron-greek # 安装PyTorch (请根据CUDA版本去官网获取对应命令) pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 安装LLM训练与推理框架 pip install transformers>=4.35.0 # Hugging Face 核心库 pip install peft>=0.6.0 # 参数高效微调（LoRA） pip install accelerate>=0.24.0 # 分布式训练加速 pip install bitsandbytes>=0.41.0 # 量化训练（可选，用于节省显存） # 安装RAG相关库 pip install langchain>=0.1.0 # LLM应用框架 pip install langchain-community # LangChain社区集成 pip install sentence-transformers>=2.2.0 # 用于生成文本向量（嵌入） pip install chromadb>=0.4.0 # 轻量级向量数据库 pip install pypdf>=3.17.0 # 处理PDF文档 pip install python-docx>=1.1.0 # 处理Word文档 pip install tiktoken # OpenAI风格的Tokenizer，用于文本切分 # 安装工具库 pip install jupyter # 用于实验和调试 pip install pandas # 数据处理 pip install tqdm # 进度条

2.3 项目目录结构设计

一个清晰的项目结构有助于团队协作和后期维护。建议按如下方式组织：

nemotron-greek-tutor/ ├── data/ # 原始数据与处理后的数据 │ ├── raw/ # 原始爬取或收集的希腊语文档（PDF, DOCX, TXT） │ ├── processed/ # 清洗、格式化后的纯文本文件 │ └── corpus.jsonl # 最终用于构建向量库的标准化语料（每行一个文档块） ├── scripts/ # 数据处理和训练脚本 │ ├── 01_corpus_mining.py │ ├── 02_data_cleaning.py │ ├── 03_build_vectorstore.py │ └── 04_train_lora.py ├── models/ # 模型文件 │ ├── embedding_model/ # 下载的嵌入模型（如 paraphrase-multilingual-MiniLM-L12-v2） │ ├── base_llm/ # 下载的基础LLM（如 Qwen2-7B-Instruct） │ └── lora_adapters/ # 训练好的LoRA适配器权重 ├── config/ # 配置文件 │ ├── embedding_config.yaml │ └── lora_training_config.yaml ├── src/ # 核心源代码 │ ├── retriever.py # 检索器封装 │ ├── generator.py # 生成器封装（集成LoRA） │ └── rag_pipeline.py # 完整的RAG流水线 ├── tests/ # 单元测试 ├── notebooks/ # Jupyter Notebook实验记录 ├── requirements.txt # 项目依赖 └── README.md # 项目说明

3. 第一步：现代希腊语专业语料库挖掘与处理

高质量的语料库是RAG系统成功的基石。对于现代希腊语专业领域，数据来源可能是多语言网站、学术数据库、数字化书籍等。

3.1 语料来源与获取策略

由于直接获取大规模、清洁的希腊语专业语料可能较难，我们可以采用混合策略：

1. 公开数据集：寻找已有的希腊语文本数据集，如欧洲议会会议记录平行语料、维基百科希腊语 dump。
2. 定向爬虫（合规前提下）：针对希腊政府公开信息网站、大学开源论文库、专业期刊网站进行爬取。务必遵守网站的robots.txt协议，并控制请求频率，避免对目标服务器造成压力。
3. 文档转换：收集已有的希腊语PDF、Word文档，使用pypdf、python-docx等库进行文本提取。

以下是一个简单的示例，展示如何使用requests和BeautifulSoup进行合规的网页内容抓取（需先安装beautifulsoup4和requests）：

import requests from bs4 import BeautifulSoup import time import re def scrape_greek_website(url, output_file): """ 从指定URL抓取希腊语文本，并保存到文件。 这是一个基础示例，实际项目需要处理分页、JavaScript渲染等复杂情况。 """ headers = { 'User-Agent': 'Mozilla/5.0 (compatible; ResearchBot/1.0; +http://yourdomain.com/bot)' } try: response = requests.get(url, headers=headers, timeout=10) response.raise_for_status() # 假设网页使用UTF-8编码，希腊语网页通常如此 response.encoding = 'utf-8' soup = BeautifulSoup(response.text, 'html.parser') # 移除脚本、样式等标签 for script in soup(["script", "style", "nav", "footer", "header"]): script.decompose() # 获取主内容，这里假设主要内容在<main>或<article>标签内，需根据目标网站调整 main_content = soup.find('main') or soup.find('article') or soup.body text = main_content.get_text(separator='\n', strip=True) # 简单的希腊语字符过滤（基本范围），保留标点 # 希腊语Unicode范围：\u0370-\u03FF（基本希腊语），\u1F00-\u1FFF（扩展） greek_pattern = re.compile(r'[^\u0370-\u03FF\u1F00-\u1FFF\s\.\,\;\:\?\!\-\(\)\d]', re.UNICODE) cleaned_text = re.sub(greek_pattern, ' ', text) cleaned_text = re.sub(r'\s+', ' ', cleaned_text).strip() if cleaned_text: with open(output_file, 'a', encoding='utf-8') as f: f.write(cleaned_text + "\n\n---DOCUMENT SEPARATOR---\n\n") print(f"成功抓取并保存内容从 {url}") else: print(f"未从 {url} 提取到有效希腊语文本") # 礼貌性延迟 time.sleep(2) except requests.RequestException as e: print(f"抓取 {url} 时出错: {e}") # 示例使用 base_url = "https://example-greek-law-site.gr/articles/page_{}" for page in range(1, 6): # 抓取前5页 url = base_url.format(page) scrape_greek_website(url, "./data/raw/scraped_law_texts.txt")

注意：大规模爬取前，务必进行法律和伦理审查。优先考虑使用官方提供的API或开放数据集。

3.2 语料清洗与预处理

抓取或获取的原始文本通常包含大量噪声，如HTML标签、广告、导航栏、无关字符等，必须进行清洗。

import re import unicodedata def clean_greek_text(text): """ 清洗希腊语文本。 """ # 1. 标准化Unicode字符（如将组合字符转换为单一字符） text = unicodedata.normalize('NFC', text) # 2. 移除多余的空白字符（换行、制表符、多个空格） text = re.sub(r'\s+', ' ', text) # 3. 移除URL text = re.sub(r'https?://\S+|www\.\S+', '', text) # 4. 移除电子邮件 text = re.sub(r'\S*@\S*\s?', '', text) # 5. 移除特定噪声模式（根据你的数据定制） # 例如，移除类似“Σελίδα 1 από 10”的分页信息 text = re.sub(r'Σελίδα\s*\d+\s*από\s*\d+', '', text) # 6. 确保句子以标点结尾（为后续分句做准备） # 如果段落结尾没有标点，添加句号。 if text and text[-1] not in '.!?;': text += '.' return text.strip() def split_into_chunks(text, chunk_size=500, chunk_overlap=50): """ 将长文本按指定大小和重叠度切分成块。 这是一个基于字符的简单切分，生产环境建议使用基于句子或语义的切分器。 """ from langchain.text_splitter import RecursiveCharacterTextSplitter text_splitter = RecursiveCharacterTextSplitter( chunk_size=chunk_size, chunk_overlap=chunk_overlap, length_function=len, separators=["\n\n", "\n", "。", "！", "？", "；", "，", " ", ""] # 针对希腊语调整分隔符 ) chunks = text_splitter.split_text(text) return chunks # 处理流程示例 raw_text = "" # 从文件读取的原始文本 cleaned_text = clean_greek_text(raw_text) text_chunks = split_into_chunks(cleaned_text) for i, chunk in enumerate(text_chunks): print(f"Chunk {i+1} (length: {len(chunk)}): {chunk[:100]}...")

3.3 构建向量数据库索引

清洗和分块后的文本需要转换为向量（嵌入），并存入向量数据库，以便后续快速检索。我们选择ChromaDB作为本地向量数据库，并使用sentence-transformers中的多语言嵌入模型。

from sentence_transformers import SentenceTransformer import chromadb from chromadb.config import Settings import json # 1. 初始化嵌入模型 # 选择一个支持希腊语的多语言模型，例如： embedding_model_name = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2" embedding_model = SentenceTransformer(embedding_model_name) # 首次使用会自动下载模型到 `./models/embedding_model/` # 2. 初始化ChromaDB客户端和集合 chroma_client = chromadb.PersistentClient(path="./data/vector_db") # 数据持久化到磁盘 collection_name = "greek_specialist_docs" # 如果集合已存在，先删除（仅用于示例，生产环境应谨慎） try: chroma_client.delete_collection(collection_name) except: pass collection = chroma_client.create_collection(name=collection_name) # 3. 准备数据：假设我们已经有了清洗分块后的语料列表 `processed_chunks` # processed_chunks = ["chunk1 text...", "chunk2 text...", ...] # 同时，我们需要为每个块生成一个唯一ID和可选的元数据（如来源、领域） documents = [] metadatas = [] ids = [] for idx, chunk in enumerate(processed_chunks): documents.append(chunk) metadatas.append({"source": "greek_law_site", "domain": "legal", "chunk_id": idx}) ids.append(f"doc_{idx}") # 4. 生成嵌入向量并添加到集合 # 注意：对于大规模数据，应分批处理，避免内存溢出 batch_size = 100 for i in range(0, len(documents), batch_size): batch_docs = documents[i:i+batch_size] batch_ids = ids[i:i+batch_size] batch_metadatas = metadatas[i:i+batch_size] # 生成嵌入向量 embeddings = embedding_model.encode(batch_docs, show_progress_bar=True, convert_to_numpy=True).tolist() # 添加到ChromaDB collection.add( embeddings=embeddings, documents=batch_docs, metadatas=batch_metadatas, ids=batch_ids ) print(f"已插入批次 {i//batch_size + 1}， 共 {len(batch_docs)} 个文档块。") print("向量数据库构建完成！")

4. 第二步：适配检索系统与训练LoRA适配器

有了知识库，下一步是让检索更精准，并让基础LLM更懂希腊语和专业领域。

4.1 优化检索策略：超越简单向量检索

简单的向量相似度检索可能不够精准。我们可以引入混合检索和重排序来提升效果。

from langchain.retrievers import BM25Retriever from langchain.retrievers import EnsembleRetriever from langchain.retrievers import ContextualCompressionRetriever from langchain.retrievers.document_compressors import CrossEncoderReranker from langchain_community.vectorstores import Chroma from langchain.embeddings import HuggingFaceEmbeddings from langchain.schema import Document import numpy as np # 1. 初始化向量检索器 (基于ChromaDB) embeddings = HuggingFaceEmbeddings(model_name=embedding_model_name) vectorstore = Chroma( collection_name=collection_name, persist_directory="./data/vector_db", embedding_function=embeddings ) vector_retriever = vectorstore.as_retriever(search_kwargs={"k": 10}) # 初步召回10个 # 2. 初始化关键词检索器 (BM25) # 需要将文档转换为BM25可用的格式 from langchain.text_splitter import CharacterTextSplitter # 假设 `full_documents` 是完整的文档列表 text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_text("\n".join(full_documents)) bm25_retriever = BM25Retriever.from_texts(texts, k=10) # 3. 构建混合检索器 ensemble_retriever = EnsembleRetriever( retrievers=[vector_retriever, bm25_retriever], weights=[0.7, 0.3] # 可以调整权重 ) # 4. 引入重排序器 (Re-ranker) # 使用一个更强的交叉编码器模型对初步检索结果进行重排序 from sentence_transformers import CrossEncoder reranker_model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2') # 注意：需要将检索到的Document对象转换为文本列表进行重排序 def rerank_documents(query, retrieved_docs, top_k=5): """ 对检索到的文档进行重排序。 """ pairs = [[query, doc.page_content] for doc in retrieved_docs] scores = reranker_model.predict(pairs) # 根据分数排序 ranked_results = [doc for _, doc in sorted(zip(scores, retrieved_docs), reverse=True)] return ranked_results[:top_k] # 封装成一个完整的检索函数 def hybrid_retrieve_with_rerank(query, top_k_final=5): # 第一步：混合检索，获取较多候选 candidate_docs = ensemble_retriever.get_relevant_documents(query) # 第二步：重排序，精选top_k final_docs = rerank_documents(query, candidate_docs, top_k=top_k_final) return final_docs # 测试检索 query = "Νομικές διατάξεις για την προστασία δεδομένων προσωπικού χαρακτήρα (GDPR)" retrieved = hybrid_retrieve_with_rerank(query) for i, doc in enumerate(retrieved): print(f"Result {i+1} (Score: N/A after rerank): {doc.page_content[:200]}...") print(f"Metadata: {doc.metadata}\n")

4.2 使用LoRA微调基础LLM

我们选择Qwen2-7B-Instruct作为基础模型，因为它对多语言支持较好，且社区活跃。使用PEFT库进行LoRA微调。

首先，准备训练数据。数据格式应为指令-输入-输出（Instruction-Input-Output）的对话格式。

[ { "instruction": "Μετάφρασε την ακόλουθη πρόταση στα Αγγλικά.", "input": "Η Ελλάδα είναι μια χώρα με πλούσια ιστορία και πολιτισμό.", "output": "Greece is a country with a rich history and culture." }, { "instruction": "Σύνοψε το κύριο επιχείρημα αυτού του νομικού κειμένου.", "input": "[一段希腊语法律文本...]", "output": "[该法律文本的希腊语摘要...]" }, { "instruction": "Απάντησε στην ερώτηση βάσει των παρεχόμενων πληροφοριών.", "input": "Πληροφορίες: [检索到的希腊语知识片段]\\nΕρώτηση: [用户希腊语问题]", "output": "[基于信息生成的希腊语答案]" } ]

然后，编写训练脚本(scripts/04_train_lora.py)：

import torch from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training from trl import SFTTrainer from datasets import Dataset import json # 1. 加载模型和分词器 model_name = "Qwen/Qwen2-7B-Instruct" tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) # 设置padding token（如果模型没有） if tokenizer.pad_token is None: tokenizer.pad_token = tokenizer.eos_token model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, # 使用BF16精度节省显存 device_map="auto", # 自动分配模型层到GPU/CPU trust_remote_code=True ) # 2. 准备模型用于LoRA训练（如果使用量化，需要这步） model = prepare_model_for_kbit_training(model) # 3. 配置LoRA参数 lora_config = LoraConfig( r=16, # LoRA秩（rank），影响参数量和能力，通常8-64 lora_alpha=32, # 缩放因子 target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"], # 针对Qwen2的模块名 lora_dropout=0.1, bias="none", task_type="CAUSAL_LM", ) model = get_peft_model(model, lora_config) model.print_trainable_parameters() # 查看可训练参数占比 # 4. 加载训练数据集 def load_training_data(file_path): with open(file_path, 'r', encoding='utf-8') as f: data = json.load(f) formatted_data = [] for item in data: # 根据你的数据格式构建prompt prompt = f"### Instruction:\n{item['instruction']}\n\n### Input:\n{item.get('input', '')}\n\n### Response:\n" # 或者使用ChatML格式 # prompt = f"<|im_start|>user\n{item['instruction']}\\n{item.get('input', '')}<|im_end|>\n<|im_start|>assistant\n" formatted_data.append({ "text": prompt + item['output'] + tokenizer.eos_token # 添加EOS token }) return Dataset.from_list(formatted_data) train_dataset = load_training_data("./data/processed/train_data.json") # 5. 配置训练参数 training_args = TrainingArguments( output_dir="./models/lora_adapters/qwen2-7b-greek-specialist", num_train_epochs=3, per_device_train_batch_size=4, # 根据GPU显存调整 gradient_accumulation_steps=4, # 模拟更大的batch size learning_rate=2e-4, fp16=False, bf16=True, # 使用BF16混合精度训练 logging_steps=10, save_steps=500, save_total_limit=2, remove_unused_columns=False, push_to_hub=False, # 如果希望上传到Hugging Face Hub report_to="tensorboard", ) # 6. 初始化Trainer trainer = SFTTrainer( model=model, args=training_args, train_dataset=train_dataset, tokenizer=tokenizer, max_seq_length=1024, # 根据你的数据长度调整 dataset_text_field="text", ) # 7. 开始训练 trainer.train() # 8. 保存LoRA适配器 trainer.model.save_pretrained(training_args.output_dir) tokenizer.save_pretrained(training_args.output_dir) print(f"LoRA适配器已保存至 {training_args.output_dir}")

关键参数解释：

• r(秩): 决定LoRA适配器的大小。值越大，能力越强，但参数量越多，可能过拟合。对于7B模型，16是一个不错的起点。
• target_modules: 指定将LoRA适配器添加到原始模型的哪些线性层。不同模型结构不同，需要查阅对应模型的文档或代码。
• per_device_train_batch_size: 根据GPU显存设置。如果出现OOM（内存不足），降低此值或使用梯度累积(gradient_accumulation_steps)。
• bf16: 在支持BF16的GPU（如Ampere架构及以上）上使用，可以节省显存并加速训练。

5. 第三步：构建完整的RAG生成流水线

将训练好的LoRA适配器加载到基础模型上，并与我们构建的检索系统结合，形成完整的问答流水线。

# src/rag_pipeline.py import torch from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline from peft import PeftModel, PeftConfig from langchain_community.vectorstores import Chroma from langchain.embeddings import HuggingFaceEmbeddings from .retriever import hybrid_retrieve_with_rerank # 导入之前写的检索函数 import warnings warnings.filterwarnings("ignore") class GreekSpecialistRAG: def __init__(self, base_model_name="Qwen/Qwen2-7B-Instruct", lora_adapter_path="./models/lora_adapters/qwen2-7b-greek-specialist"): # 1. 加载基础模型和分词器 self.tokenizer = AutoTokenizer.from_pretrained(base_model_name, trust_remote_code=True) if self.tokenizer.pad_token is None: self.tokenizer.pad_token = self.tokenizer.eos_token self.base_model = AutoModelForCausalLM.from_pretrained( base_model_name, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True ) # 2. 加载LoRA适配器并合并到基础模型 self.model = PeftModel.from_pretrained(self.base_model, lora_adapter_path) self.model = self.model.merge_and_unload() # 合并适配器，便于推理 self.model.eval() # 3. 初始化文本生成管道 self.generator = pipeline( "text-generation", model=self.model, tokenizer=self.tokenizer, device_map="auto", torch_dtype=torch.bfloat16, ) # 4. 初始化检索器（这里需要你实现或导入） # 假设我们已经有了一个初始化好的混合检索器 `self.retriever` self.embedding_model_name = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2" self.embeddings = HuggingFaceEmbeddings(model_name=self.embedding_model_name) self.vectorstore = Chroma( collection_name="greek_specialist_docs", persist_directory="./data/vector_db", embedding_function=self.embeddings ) # 简单使用向量检索作为示例，实际可使用更复杂的 `hybrid_retrieve_with_rerank` self.retriever = self.vectorstore.as_retriever(search_kwargs={"k": 5}) print("Greek Specialist RAG Pipeline 初始化完成。") def retrieve(self, query): """检索相关文档""" docs = self.retriever.get_relevant_documents(query) context = "\n\n".join([doc.page_content for doc in docs]) return context def build_prompt(self, query, context): """构建提示词模板""" # 使用适合你微调数据格式的模板 prompt_template = f"""Ακολουθεί πληροφορία από ένα εγχειρίδιο για Ειδικούς Τομείς στα Νέα Ελληνικά. Πληροφορίες: {context} Με βάση τις παραπάνω πληροφορίες, απάντησε στην ακόλουθη ερώτηση. Αν η απάντηση δεν βρίσκεται στις πληροφορίες, πες «Δεν μπορώ να βρω την απάντηση στις παρεχόμενες πληροφορίες.» Ερώτηση: {query} Απάντηση:""" return prompt_template def generate(self, query, max_new_tokens=512): """生成答案""" # 检索 context = self.retrieve(query) # 构建提示 prompt = self.build_prompt(query, context) # 生成 with torch.no_grad(): outputs = self.generator( prompt, max_new_tokens=max_new_tokens, do_sample=True, # 启用采样以获得更自然的文本 temperature=0.7, # 控制随机性 top_p=0.9, # 核采样 repetition_penalty=1.1, # 避免重复 eos_token_id=self.tokenizer.eos_token_id, pad_token_id=self.tokenizer.pad_token_id, ) answer = outputs[0]['generated_text'].split("Απάντηση:")[-1].strip() return answer, context # 使用示例 if __name__ == "__main__": rag_system = GreekSpecialistRAG() query = "Ποιες είναι οι βασικές αρχές της προστασίας δεδομένων υπό τον Γενικό Κανονισμό Προστασίας Δεδομένων (GDPR);" answer, retrieved_context = rag_system.generate(query) print("=== 问题 ===") print(query) print("\n=== 检索到的上下文 ===") print(retrieved_context[:500] + "...") print("\n=== 生成的答案 ===") print(answer)

6. 系统评估、常见问题与优化

构建完系统后，必须进行评估和迭代优化。

6.1 评估指标与方法

对于RAG系统，不能只看生成答案的通顺度，需要多维度评估：

可以构建一个包含问题、标准答案和参考上下文的测试集，进行自动化或半自动化评估。

6.2 常见问题排查清单

在开发和运行过程中，你可能会遇到以下问题：

6.3 生产环境最佳实践

当系统准备上线时，需要考虑以下方面：

1. 配置化管理：将所有路径、模型名称、超参数（如top_k, temperature）放入配置文件（如YAML），避免硬编码。
2. 日志与监控：记录每一次查询的检索结果、生成答案、耗时和可能的错误。这有助于后续分析和优化。
3. 缓存机制：对频繁出现的查询及其答案进行缓存，可以显著降低响应延迟和计算成本。
4. 版本控制：对语料库、嵌入模型、基础LLM、LoRA适配器进行版本管理。任何组件的更新都应记录并可回滚。
5. 安全与合规：确保你的知识库来源合法合规。对于生成的内容，考虑添加免责声明，并建立人工审核机制处理敏感查询。
6. 可扩展性：考虑将检索服务、模型推理服务拆分为独立的微服务，便于独立扩缩容和维护。

通过以上步骤，我们完成了一个从语料挖掘、检索优化、模型微调到系统集成的完整“Teaching Nemotron Greek”项目流程。这个流程不仅适用于希腊语，也可以迁移到其他语言或垂直领域。核心在于理解RAG与微调的分工与协作，并针对具体场景精心处理数据、优化检索策略和设计训练目标。