如果你正在尝试用大模型处理法律文本，可能会遇到这样的困境：模型要么一本正经地胡说八道，把“盗窃”和“抢劫”混为一谈；要么对最新的司法解释一问三不知；或者，当你试图让它预测一个具体案件的刑期时，它给出的答案总是过于笼统，缺乏法律依据。

这背后的问题在于，通用大模型缺乏垂直领域的专业知识，而法律文本的严谨性、时效性和复杂性，对模型的“知识”和“推理”能力提出了双重挑战。单纯调用API或使用基础模型，很难满足专业场景的需求。

今天，我们就来“手撕”一个能真正解决这些痛点的方案： 基于 Qwen 大模型，结合 RAG（检索增强生成）和 LoRA（低秩适应）微调技术，构建一个面向刑法领域的专业应用 。这个应用将能实现：

1. 精准的罪名识别 ：输入案情描述，准确输出可能涉及的罪名。
2. 有依据的刑期预测 ：结合案情情节和法律规定，给出量刑区间参考。
3. 准确的司法解释生成 ：针对具体法律条文或概念，生成贴合当前司法实践的解读。

更重要的是，本文将不止步于概念，而是带你从零开始，一步步搭建环境、准备数据、训练模型、部署应用，并附上完整的代码和详细的Debug记录（来自“DeepSeek学长”的实战经验）。无论你是想将AI应用于法律科技、学术研究，还是单纯想深入掌握RAG和LoRA这两项当前最热门的AI工程化技术，这篇文章都将提供一条清晰的实践路径。

1. 为什么需要“Qwen+RAG+LoRA”这个组合拳？

在深入代码之前，我们必须先理解为什么是这三个技术的组合，而不是单独使用其中任何一个。这决定了我们项目的架构是否合理。

场景假设 ：你输入一段案情：“张三在夜间潜入李四家，窃取现金5000元后离开。”

• 只用基础Qwen模型 ：它可能知道这是“盗窃”，但无法准确区分“入户盗窃”与普通盗窃（后者量刑更重），也可能不知道5000元在某些省份是否构成“数额较大”。它依赖的是训练数据中的通用知识，缺乏对最新《量刑指导意见》的感知。
• 只用RAG（检索增强生成） ：我们可以建立一个法律知识库（刑法、司法解释、案例）。当用户提问时，RAG会先从知识库中检索相关法条和案例，再将它们和问题一起交给模型生成答案。这解决了知识时效性和依据问题。但如果模型本身对法律文本的理解和生成格式不佳，即使给了它正确的法条，它也可能组织不出专业、严谨的回答。
• 只用LoRA微调 ：我们用大量法律问答对微调Qwen，可以让模型学会法律领域的语言风格和推理模式。但它仍然是一个“死记硬背”的模型，无法获取训练数据之外的新知识（如刚发布的司法解释）。

因此，组合的优势显而易见 ：

1. RAG 提供“外挂知识库” ：保证答案的准确性和有据可查。它负责“知其然，亦知其所以然”中的“所以然”。
2. LoRA 微调塑造“法律专家思维” ：让模型更擅长理解法律语境、遵循法律文书格式、进行法律逻辑推理。它负责提升模型在垂直领域的“基础素养”。
3. Qwen 作为强大的“基座模型” ：提供优秀的通用语言理解和生成能力。通义千问（Qwen）系列模型在中文理解和推理上表现突出，且完全开源，适合作为基座。

简单来说，RAG让模型“有据可查”，LoRA让模型“像个律师”，两者结合，才能打造出一个可靠的法律AI助手。 这个架构思路，同样适用于金融、医疗、客服等其他专业知识密集型领域。

2. 核心概念与工具链简介

在动手之前，快速厘清几个核心概念和我们将要使用的工具。

2.1 Qwen：我们的“大脑”基座

Qwen（通义千问）是阿里云开源的大语言模型系列。我们选择它是因为：

• 出色的中文能力 ：对中文法律文本的理解和生成有天然优势。
• 模型规格丰富 ：从0.5B到72B，满足从本地部署到云端服务的不同需求。对于本实验， Qwen2.5-7B-Instruct 是一个很好的起点，在精度和资源消耗间取得平衡。
• 完全开源 ：可商用，允许微调和私有化部署。

2.2 RAG：模型的“法律图书馆”

RAG（Retrieval-Augmented Generation）检索增强生成，核心流程如下：

1. 索引 ：将法律条文、司法解释、典型案例等文档切块、向量化，存入向量数据库。
2. 检索 ：当用户提问时，将问题向量化，从向量数据库中找出最相关的文本块。
3. 增强 ：将检索到的相关文本作为“上下文”，和用户问题一起拼接，提交给大模型。
4. 生成 ：大模型基于自身能力和提供的“上下文”，生成最终答案。

关键工具 ：

• 文本加载与切分 ： LangChain 的 RecursiveCharacterTextSplitter 。
• 向量化模型 ： BAAI/bge-large-zh-v1.5 ，一个优秀的中文文本向量化模型。
• 向量数据库 ： ChromaDB ，轻量、易用，适合学习和原型开发。

2.3 LoRA：模型的“专项特训”

全参数微调大模型成本极高。LoRA（Low-Rank Adaptation）是一种高效的微调技术。它冻结预训练模型的权重，只在原始模型结构中注入少量的、可训练的“低秩适配器”参数。微调时只更新这些适配器，从而大幅降低训练开销。

• 优势 ：速度快，显存占用少，产出的模型权重文件小（通常只有几十MB），易于分享和部署。
• 工具 ：我们将使用 PEFT (Parameter-Efficient Fine-Tuning) 库来实现LoRA。

2.4 项目整体架构图

用户提问
    |
    v
[前端/接口] -> 接收问题
    |
    v
[RAG 引擎]
    |--> 将问题向量化
    |--> 查询向量数据库 (ChromaDB)
    |--> 返回Top-K相关法律文本片段
    |
    v
[提示词工程] -> 拼接：“基于以下法律依据：{检索结果}，请回答：{用户问题}”
    |
    v
[微调后的Qwen模型] (Qwen基座 + LoRA适配器)
    |
    v
生成最终答案 -> 罪名/刑期预测/司法解释

3. 环境准备与依赖安装

我们将在一个Python环境中完成所有工作。建议使用Python 3.10或3.11。

步骤1：创建并激活虚拟环境

conda create -n law_llm python=3.10 -y
conda activate law_llm

步骤2：安装核心依赖 创建一个 requirements.txt 文件，内容如下：

# 基础与深度学习框架
torch>=2.0.0
transformers>=4.36.0
accelerate>=0.25.0
peft>=0.8.0  # LoRA微调库
datasets>=2.14.0  # 数据处理

# RAG相关
langchain>=0.1.0
langchain-community>=0.0.10
chromadb>=0.4.0  # 向量数据库
sentence-transformers>=2.2.0  # 用于BGE向量模型
pypdf>=3.17.0  # 用于读取PDF法律文件
unstructured>=0.10.30  # 文档解析

# 其他工具
tiktoken  # Qwen分词器
gradio>=4.0.0  # 快速构建Web界面
python-dotenv  # 管理环境变量

执行安装命令：

pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

步骤3：验证关键库及硬件

# check_env.py
import torch
print(f"PyTorch版本: {torch.__version__}")
print(f"CUDA是否可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU设备: {torch.cuda.get_device_name(0)}")
    print(f"CUDA版本: {torch.version.cuda}")

运行它，确保你的CUDA环境正常。本教程假设你有一张至少8GB显存的GPU（如RTX 3070/4060等）。

4. 数据准备：构建法律知识库与微调数据集

高质量的数据是项目成功的基石。我们需要准备两类数据：

1. RAG知识库数据 ：用于检索的原始法律文本。
2. LoRA微调数据 ：用于训练模型的问答对。

4.1 准备RAG知识库数据

我们可以从公开渠道获取法律文本，例如：

• 《中华人民共和国刑法》全文
• 《最高人民法院关于常见犯罪的量刑指导意见》
• 重要的刑法司法解释
• 精选的权威案例（裁判文书网公开内容，需脱敏）

将这些文档保存为 data/raw_law/ 目录下的 .txt 或 .pdf 文件。目录结构如下：

data/
├── raw_law/
│   ├── criminal_law.txt          # 刑法全文
│   ├── sentencing_guidelines.txt # 量刑指导意见
│   └── judicial_interpretations/ # 司法解释目录
│       ├── interpretation_1.txt
│       └── interpretation_2.txt
└── fine_tune/
    └── train.jsonl               # 微调数据集

示例： criminal_law.txt 片段

第二百六十四条 【盗窃罪】盗窃公私财物，数额较大的，或者多次盗窃、入户盗窃、携带凶器盗窃、扒窃的，处三年以下有期徒刑、拘役或者管制，并处或者单处罚金；数额巨大或者有其他严重情节的，处三年以上十年以下有期徒刑，并处罚金；数额特别巨大或者有其他特别严重情节的，处十年以上有期徒刑或者无期徒刑，并处罚金或者没收财产。

4.2 准备LoRA微调数据

微调数据需要是高质量的问答对，格式为JSON Lines（ .jsonl ），每条记录包含 instruction （指令）、 input （输入，可选）、 output （输出）。

示例： data/fine_tune/train.jsonl

{"instruction": "请根据以下案情描述，识别可能涉及的罪名。", "input": "被告人王某在公交车上，趁乘客刘某不备，用刀片划开其背包，窃取钱包一个，内有现金2000元。", "output": "可能涉嫌【盗窃罪】。本案中，王某在公共场所扒窃他人随身携带的财物，其行为符合盗窃罪的构成要件。且扒窃行为不要求数额较大即可入罪。"}
{"instruction": "请预测以下案情的量刑区间。", "input": "李某盗窃他人财物，价值人民币5000元，到案后如实供述罪行，并积极退赔，取得被害人谅解。", "output": "【量刑区间参考】根据《刑法》第二百六十四条，盗窃5000元属于‘数额较大’，基准刑为三年以下有期徒刑、拘役或管制。\n【从宽情节】1. 到案后如实供述，可减少基准刑的10%以下；2. 积极退赔并取得谅解，可减少基准刑的20%以下。\n【综合预测】综合考虑，可能判处拘役四至六个月，并处罚金，或适用缓刑。"}
{"instruction": "请生成关于‘入户盗窃’的司法解释。", "input": "", "output": "根据《最高人民法院、最高人民检察院关于办理盗窃刑事案件适用法律若干问题的解释》第三条，非法进入供他人家庭生活，与外界相对隔离的住所盗窃的，应当认定为‘入户盗窃’。\n‘入户盗窃’的认定要点：1. ‘户’指家庭住所；2. ‘入户’目的具有非法性；3. 盗窃行为发生在户内。\n‘入户盗窃’在量刑上，不要求盗窃数额达到‘较大’标准即可构成盗窃罪，且作为从重处罚情节。"}

你需要收集或构造数百至数千条这样的高质量数据。数据质量直接决定微调后模型的“专业程度”。

5. RAG知识库构建实战

有了原始文本，我们现在将其处理成可检索的知识库。

步骤1：加载与分割文档

# build_rag_knowledge.py
import os
from langchain_community.document_loaders import DirectoryLoader, TextLoader, PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import Chroma

# 1. 加载文档
law_data_path = "./data/raw_law"
loaders = []
for root, dirs, files in os.walk(law_data_path):
    for file in files:
        file_path = os.path.join(root, file)
        if file.endswith('.txt'):
            loaders.append(TextLoader(file_path, encoding='utf-8'))
        elif file.endswith('.pdf'):
            loaders.append(PyPDFLoader(file_path))

documents = []
for loader in loaders:
    documents.extend(loader.load())
print(f"共加载 {len(documents)} 个文档")

# 2. 分割文本（法律条文通常较长，需要合理切分）
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,  # 每个块约500字符
    chunk_overlap=100,  # 块间重叠100字符，保持上下文
    separators=["\n\n", "\n", "。", "；", "，", " ", ""]  # 按中文标点分割
)
chunks = text_splitter.split_documents(documents)
print(f"分割为 {len(chunks)} 个文本块")

步骤2：向量化并存入向量数据库

# 3. 初始化嵌入模型（使用BGE中文模型）
embedding_model = HuggingFaceEmbeddings(
    model_name="BAAI/bge-large-zh-v1.5",
    model_kwargs={'device': 'cuda'},  # 使用GPU加速
    encode_kwargs={'normalize_embeddings': True}  # 归一化，提升检索效果
)

# 4. 创建并持久化向量数据库
vector_db_path = "./vector_db/law_chroma"
vectordb = Chroma.from_documents(
    documents=chunks,
    embedding=embedding_model,
    persist_directory=vector_db_path
)
vectordb.persist()  # 保存到磁盘
print(f"向量数据库已构建并保存至 {vector_db_path}")

关键点解析 ：

• chunk_size ：不宜过大，否则检索精度下降；不宜过小，否则失去上下文。500-1000对于法律条文较合适。
• BAAI/bge-large-zh-v1.5 ：是目前中文领域表现最好的开源文本向量模型之一，检索精度高。
• ChromaDB ：将向量和文本存储在本地，方便后续检索。

6. LoRA微调Qwen模型实战

这是让模型具备“法律思维”的关键一步。

步骤1：加载基座模型与分词器

# fine_tune_lora.py
from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments
from peft import LoraConfig, get_peft_model, TaskType
from datasets import load_dataset
import torch

# 1. 指定模型路径（使用Qwen2.5-7B-Instruct）
model_name = "Qwen/Qwen2.5-7B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)

# 注意：Qwen模型需要设置pad_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
)
print("基座模型与分词器加载完毕。")

步骤2：配置LoRA参数

# 2. 配置LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,  # 因果语言模型任务
    inference_mode=False,          # 训练模式
    r=8,                           # LoRA秩，影响参数量，通常8-32
    lora_alpha=32,                 # 缩放因子
    lora_dropout=0.1,              # Dropout防止过拟合
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]  # 对Transformer的哪些层应用LoRA
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # 打印可训练参数量，应该只占原模型很小一部分

步骤3：准备训练数据

# 3. 加载并处理微调数据集
dataset = load_dataset('json', data_files='./data/fine_tune/train.jsonl', split='train')

def format_instruction(example):
    # 将数据格式化为Qwen的对话格式
    prompt = f"<|im_start|>system\n你是一个专业的法律AI助手，请根据中国法律知识严谨回答问题。<|im_end|>\n<|im_start|>user\n"
    if example['input']:
        prompt += f"{example['instruction']}\n{example['input']}<|im_end|>\n<|im_start|>assistant\n"
    else:
        prompt += f"{example['instruction']}<|im_end|>\n<|im_start|>assistant\n"
    prompt += f"{example['output']}<|im_end|>"
    example['text'] = prompt
    return example

dataset = dataset.map(format_instruction)

# 分词
def tokenize_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=512)

tokenized_dataset = dataset.map(tokenize_function, batched=True, remove_columns=dataset.column_names)

步骤4：配置训练参数并开始训练

# 4. 设置训练参数
training_args = TrainingArguments(
    output_dir="./output/qwen_lora_law",  # 输出目录
    per_device_train_batch_size=4,        # 根据GPU显存调整
    gradient_accumulation_steps=4,         # 梯度累积，等效增大batch size
    num_train_epochs=3,                   # 训练轮数
    learning_rate=2e-4,                    # 学习率，LoRA通常可以设大一点
    fp16=True,                            # 使用混合精度训练，节省显存
    logging_steps=10,
    save_steps=200,
    save_total_limit=2,
    remove_unused_columns=False,
    push_to_hub=False,                     # 不推送至Hugging Face Hub
    report_to="tensorboard",
)

# 5. 使用Transformers Trainer进行训练
from transformers import Trainer, DataCollatorForLanguageModeling

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    data_collator=DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False),
)

print("开始LoRA微调训练...")
trainer.train()
trainer.save_model()  # 保存LoRA权重
tokenizer.save_pretrained(training_args.output_dir)
print(f"训练完成，模型保存在 {training_args.output_dir}")

DeepSeek学长Debug记录 ：

• 问题1 ：训练时出现 CUDA out of memory 。
  • 排查 ： per_device_train_batch_size 设置过大。
  • 解决 ：将其从8降低到4，并启用 gradient_accumulation_steps=4 ，保持总batch size为16。同时启用 fp16 混合精度。
• 问题2 ：模型输出乱码或重复。
  • 排查 ：数据格式不对，没有遵循Qwen的对话模板。
  • 解决 ：严格按照 format_instruction 函数中的 <|im_start|> 和 <|im_end|> 格式构造提示词。
• 问题3 ：训练损失不下降。
  • 排查 ：学习率可能不合适，或数据质量太差。
  • 解决 ：将学习率从5e-5调整为2e-4。检查并清洗微调数据，确保问答对质量。

7. 整合RAG与微调模型进行推理

现在，我们将训练好的LoRA权重加载到Qwen基座模型上，并与RAG检索系统结合，构建完整的问答流程。

步骤1：加载带LoRA权重的模型

# inference_rag_lora.py
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
from peft import PeftModel
from langchain.vectorstores import Chroma
from langchain.embeddings import HuggingFaceEmbeddings

# 1. 加载基座模型和分词器
base_model_name = "Qwen/Qwen2.5-7B-Instruct"
lora_model_path = "./output/qwen_lora_law"  # 上一步保存的LoRA权重路径

tokenizer = AutoTokenizer.from_pretrained(base_model_name, trust_remote_code=True)
base_model = AutoModelForCausalLM.from_pretrained(
    base_model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

# 2. 加载LoRA适配器并合并到基座模型
model = PeftModel.from_pretrained(base_model, lora_model_path)
model = model.merge_and_unload()  # 将LoRA权重合并到原模型，便于推理
model.eval()
print("融合LoRA权重的模型加载完毕。")

步骤2：加载RAG向量数据库

# 3. 加载RAG向量数据库
embedding_model = HuggingFaceEmbeddings(
    model_name="BAAI/bge-large-zh-v1.5",
    model_kwargs={'device': 'cuda'},
    encode_kwargs={'normalize_embeddings': True}
)
vector_db_path = "./vector_db/law_chroma"
vectordb = Chroma(persist_directory=vector_db_path, embedding_function=embedding_model)
retriever = vectordb.as_retriever(search_kwargs={"k": 3})  # 检索最相关的3个片段
print("RAG检索器加载完毕。")

步骤3：构建提示词模板与推理函数

# 4. 构建提示词模板
def build_rag_prompt(query, retrieved_docs):
    """
    构建结合检索结果的提示词。
    """
    context = "\n\n".join([doc.page_content for doc in retrieved_docs])
    
    prompt = f"""<|im_start|>system
你是一个专业的法律AI助手。请严格依据提供的法律依据，以严谨、专业的口吻回答用户问题。如果提供的依据不足以完全回答问题，可以结合一般法律原则进行推理，但需注明。
<|im_end|>
<|im_start|>user
请基于以下法律依据回答问题。

【相关法律依据】：
{context}

【用户问题】：
{query}
<|im_end|>
<|im_start|>assistant
"""
    return prompt

# 5. 推理函数
def ask_lawyer(query):
    # 步骤1: 检索
    relevant_docs = retriever.get_relevant_documents(query)
    
    # 步骤2: 构建提示词
    prompt = build_rag_prompt(query, relevant_docs)
    
    # 步骤3: 模型生成
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=512,        # 生成最大长度
            temperature=0.3,            # 较低的温度使输出更确定、专业
            top_p=0.9,                  # 核采样
            do_sample=True,
            repetition_penalty=1.1,     # 避免重复
            pad_token_id=tokenizer.pad_token_id,
            eos_token_id=tokenizer.eos_token_id,
        )
    
    # 步骤4: 解码并提取助手回复
    full_response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # 提取assistant部分
    assistant_start = full_response.find("<|im_start|>assistant")
    if assistant_start != -1:
        assistant_response = full_response[assistant_start:].split("<|im_end|>")[0]
        assistant_response = assistant_response.replace("<|im_start|>assistant\n", "").strip()
    else:
        assistant_response = full_response.strip()
    
    # 步骤5: 返回答案和检索依据（用于展示）
    return {
        "answer": assistant_response,
        "retrieved_context": [doc.page_content for doc in relevant_docs]
    }

步骤4：进行测试

# 6. 测试问答
if __name__ == "__main__":
    test_questions = [
        "张三在公交车上扒窃了2000元，构成什么罪？",
        "李四盗窃5000元，但有自首和退赔情节，大概会判多久？",
        "什么是‘入户盗窃’？",
    ]
    
    for q in test_questions:
        print(f"\n=== 问题：{q} ===")
        result = ask_lawyer(q)
        print("【模型回答】:")
        print(result["answer"])
        print("\n【检索到的法律依据】:")
        for i, ctx in enumerate(result["retrieved_context"], 1):
            print(f"{i}. {ctx[:200]}...")  # 只打印前200字符
        print("-" * 50)

8. 部署为Web应用（使用Gradio）

为了让非开发者也能体验，我们使用Gradio快速构建一个Web界面。

# app.py
import gradio as gr
from inference_rag_lora import ask_lawyer  # 导入上面写好的推理函数

# 定义Gradio界面函数
def gradio_ask(question, history):
    # history是Gradio Chatbot格式，我们这里简单处理单轮
    result = ask_lawyer(question)
    answer = result["answer"]
    # 可以简单格式化一下检索依据，在回答后显示
    formatted_context = "\n\n**参考依据**：\n" + "\n".join([f"- {ctx[:150]}..." for ctx in result["retrieved_context"]])
    full_response = answer + formatted_context
    return full_response

# 构建界面
with gr.Blocks(title="刑法大模型助手", theme=gr.themes.Soft()) as demo:
    gr.Markdown("# ⚖️ 刑法大模型助手：罪名识别/刑期预测/司法解释生成")
    gr.Markdown("基于Qwen+RAG+LoRA构建，回答仅供参考，不构成正式法律意见。")
    
    with gr.Row():
        with gr.Column(scale=3):
            chatbot = gr.Chatbot(label="对话历史", height=500)
            msg = gr.Textbox(label="请输入您的法律问题", placeholder="例如：盗窃5000元怎么判？", lines=3)
        with gr.Column(scale=2):
            gr.Markdown("### 示例问题")
            gr.Examples(
                examples=[
                    "抢劫和抢夺有什么区别？",
                    "诈骗罪数额巨大的标准是多少？",
                    "有自首情节一般能减刑多少？",
                    "请解释‘故意伤害罪致人重伤’的认定。"
                ],
                inputs=msg,
                label="点击试试"
            )
            gr.Markdown("### 功能说明")
            gr.Markdown("""
            - **罪名识别**：分析案情，识别可能罪名。
            - **刑期预测**：结合情节，给出量刑区间参考。
            - **法条解释**：生成对法律概念的司法解释。
            - **所有回答均基于《刑法》及相关司法解释**。
            """)
    
    with gr.Row():
        submit_btn = gr.Button("提交问题", variant="primary")
        clear_btn = gr.Button("清空对话")
    
    # 定义交互逻辑
    def respond(message, chat_history):
        bot_message = gradio_ask(message, chat_history)
        chat_history.append((message, bot_message))
        return "", chat_history
    
    msg.submit(respond, [msg, chatbot], [msg, chatbot])
    submit_btn.click(respond, [msg, chatbot], [msg, chatbot])
    clear_btn.click(lambda: None, None, chatbot, queue=False)

# 启动应用
if __name__ == "__main__":
    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)  # share=True可生成临时公网链接

运行 python app.py ，在浏览器中打开 http://localhost:7860 即可与你的刑法大模型助手对话。

9. 常见问题与排查思路（DeepSeek学长Debug宝典）

在实践过程中，你很可能遇到以下问题。这里提供了系统的排查思路。

问题现象	可能原因	排查方式	解决方案
模型加载失败，报错 KeyError 或 AttributeError	1. Transformers或PEFT库版本不兼容。 2. 模型路径错误或权重文件损坏。 3. Qwen模型需要 trust_remote_code=True 。	1. 检查 transformers , peft , torch 版本。 2. 验证模型文件是否完整下载。 3. 查看完整错误堆栈。	1. 创建新的虚拟环境，严格按 requirements.txt 安装。 2. 重新下载模型或检查路径。 3. 加载模型时务必加上 trust_remote_code=True 。
训练时GPU显存溢出（OOM）	1. per_device_train_batch_size 太大。 2. 模型太大（如用了14B/32B模型）。 3. 未使用梯度累积或混合精度。	1. 使用 nvidia-smi 监控显存。 2. 尝试将batch size设为1。	1. 减小 batch_size ，增大 gradient_accumulation_steps 。 2. 启用 fp16 或 bf16 混合精度训练。 3. 使用 Qwen2.5-1.5B/3B 等更小模型进行实验。
RAG检索结果不相关	1. 文本切分 ( chunk_size ) 不合理。 2. 嵌入模型 ( BGE ) 不适合法律领域。 3. 检索数量 k 设置不当。	1. 打印检索到的文本块，人工判断相关性。 2. 尝试不同的 chunk_size (300, 500, 800)。 3. 测试其他嵌入模型。	1. 调整 chunk_size 和 chunk_overlap 。 2. 可尝试法律领域微调过的嵌入模型（如 law-bert ）。 3. 调整 search_kwargs={"k": 5} 或使用 MMR 搜索提升多样性。
模型回答未引用检索内容，或胡编乱造	1. 提示词 ( prompt ) 未强调依据上下文。 2. 模型微调不充分，忽略了 instruction 。 3. 检索到的上下文质量太差。	1. 检查构建的完整prompt。 2. 增加微调数据中“依据上述法条回答”的样本。 3. 检查检索结果。	1. 强化prompt，如“ 必须严格依据 提供的法律依据回答”。 2. 在微调数据中，明确要求模型先复述依据再回答。 3. 提升知识库文档质量，清理无关文本。
模型输出格式混乱，包含特殊标记	1. 对话模板未正确拼接。 2. 分词或解码时未处理特殊token。	1. 打印出送入模型的完整prompt字符串。 2. 检查 tokenizer.decode 的参数。	1. 严格遵循Qwen官方对话格式： <|im_start|>role 和 <|im_end|> 。 2. 使用 skip_special_tokens=True 解码。
Gradio界面启动后无法访问	1. 端口被占用。 2. 防火墙或网络设置问题。 3. server_name 设置错误。	1. 检查端口 7860 是否被其他程序使用。 2. 尝试 localhost 而非 0.0.0.0 。	1. 更换端口： demo.launch(server_port=7861) 。 2. 本地访问使用 server_name="127.0.0.1" 。 3. 确保在虚拟环境中安装了 gradio 。

10. 最佳实践与进阶优化建议

完成基础搭建后，你可以从以下方向优化你的法律大模型，使其更专业、更可靠。

10.1 数据质量是生命线

• 知识库文档 ：确保法律文本的权威性、完整性和时效性。定期更新司法解释和典型案例。
• 微调数据 ：
  • 多样性 ：覆盖更多罪名、情节、问答类型。
  • 准确性 ：答案最好由法律专业人士审核，或来源于权威裁判文书。
  • 格式规范 ：统一答案的表述风格，如“【罪名】...【法条依据】...【量刑考量】...”。

10.2 提示词工程优化

• 系统提示词 ：明确模型角色、回答风格和边界。例如：“你是一名严谨的刑事律师助理，只基于中国现行刑法及司法解释回答...”
• 上下文组织 ：在prompt中清晰分隔“系统指令”、“检索依据”、“用户问题”、“回答格式要求”。
• 少样本学习 ：在prompt中提供1-2个高质量示例（Few-shot），能显著提升模型输出格式的稳定性。

10.3 RAG检索策略增强

• 混合检索 ：结合 稠密向量检索 （当前用的）和 稀疏检索 （如BM25）。前者语义理解强，后者关键词匹配准。LangChain支持 EnsembleRetriever 。
• 重排序 ：检索出Top-K个结果后，用一个更小的、更精确的模型（如 BGE-reranker ）对它们进行重排序，将最相关的放在前面。
• 元数据过滤 ：为每个文本块添加元数据（如“文档类型：刑法条文”、“发布年份：2021”），检索时可按需过滤。

10.4 模型微调进阶

• 全参数微调 vs. LoRA ：如果数据量足够大（数万条），且追求极致性能，可以考虑对7B模型进行全参数微调，但这需要更多的计算资源。
• 多任务学习 ：将罪名识别、刑期预测、法条问答等任务数据混合训练，让模型成为一个“多面手”。
• 评估与迭代 ：构建一个 测试集 ，定期评估模型在各项任务上的准确率、F1值等指标，根据评估结果迭代数据和模型。

10.5 工程化与部署

• API服务化 ：将核心推理逻辑封装为FastAPI或Flask API，方便与其他系统集成。
• 缓存机制 ：对常见问题（如“什么是盗窃罪？”）的检索结果和模型回答进行缓存，大幅提升响应速度。
• 日志与监控 ：记录用户的每一个问题和模型的回答，用于分析模型短板和迭代数据。监控API的响应时间和资源消耗。

通过这个项目，你不仅搭建了一个可用的法律大模型应用，更深入实践了RAG和LoRA这两项构建行业大模型应用的核心技术。这套“基座模型 + 领域知识库 + 轻量化微调”的范式，具有很强的通用性，你可以轻松地将它迁移到医疗、金融、教育等任何需要专业知识与生成能力结合的领域。