website/QWEN-TRAINING.md

Qwen模型训练与部署指南

本文档详细介绍如何训练和部署Qwen模型用于OmniVerse智能健康咨询服务。

目录

• 环境准备
• 使用Ollama部署
• 知识库准备
• 模型微调
• LangChain集成
• 性能优化

环境准备

硬件要求

• Qwen2.5-32B: 至少64GB内存，建议使用GPU（VRAM 24GB+）
• Qwen2.5-14B: 至少32GB内存，建议使用GPU（VRAM 16GB+）
• Qwen2.5-7B: 至少16GB内存，可在CPU上运行

软件环境

# 安装Python环境
python -m venv venv
source venv/bin/activate  # Linux/Mac
# venv\Scripts\activate  # Windows

# 安装依赖
pip install transformers torch datasets accelerate
pip install ollama langchain chromadb

使用Ollama部署

1. 安装Ollama

# macOS/Linux
curl -fsSL https://ollama.ai/install.sh | sh

# Windows
# 下载安装包：https://ollama.ai/download/windows

2. 下载Qwen模型

# 下载不同版本的Qwen模型
ollama pull qwen2.5:32b    # 32B参数版本（推荐，效果最好）
ollama pull qwen2.5:14b    # 14B参数版本（平衡性能）
ollama pull qwen2.5:7b     # 7B参数版本（轻量级）

# 查看已安装的模型
ollama list

3. 启动Ollama服务

# 启动服务（默认端口11434）
ollama serve

# 测试模型
curl http://localhost:11434/api/generate -d '{
  "model": "qwen2.5:32b",
  "prompt": "介绍一下OmniVerse公司"
}'

4. 创建定制化模型

创建 Modelfile 文件：

FROM qwen2.5:32b

# 设置系统提示词
SYSTEM """你是OmniVerse（灵境万象）公司的智能健康顾问助手。OmniVerse是一家专注于AI+健康领域的科技公司。

公司核心产品：
1. 智能穿戴设备：24/7健康监测，心率、血氧、睡眠分析
2. 护理机器人：智能陪伴、健康提醒、远程医疗
3. 健康数据平台：AI预测、数据分析、医疗协作

请专业、友好地回答用户问题。"""

# 设置参数
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_predict 2048

创建定制模型：

# 基于Modelfile创建新模型
ollama create omniverse-assistant -f ./Modelfile

# 运行定制模型
ollama run omniverse-assistant

知识库准备

1. 生成知识库数据

# 运行知识库准备脚本
node scripts/prepare-knowledge-base.js

# 生成的文件：
# - knowledge-base/knowledge-base.json（完整知识库）
# - knowledge-base/training-data.jsonl（训练数据）
# - knowledge-base/chat-data.jsonl（对话数据）

2. 数据格式说明

训练数据格式（JSONL）：

{"instruction": "介绍OmniVerse公司", "input": "", "output": "OmniVerse是..."}
{"instruction": "智能手表有哪些功能", "input": "", "output": "我们的智能手表..."}

对话数据格式：

{"messages": [
  {"role": "user", "content": "你们的产品有哪些？"},
  {"role": "assistant", "content": "我们有三大产品线..."}
]}

模型微调

方法1：使用Ollama的RAG（推荐）

不需要真正微调模型，而是使用RAG（检索增强生成）技术：

from langchain.llms import Ollama
from langchain.embeddings import OllamaEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
import json

# 初始化Ollama
llm = Ollama(model="qwen2.5:32b", base_url="http://localhost:11434")
embeddings = OllamaEmbeddings(model="qwen2.5:32b")

# 加载知识库
with open("knowledge-base/knowledge-base.json", "r", encoding="utf-8") as f:
    knowledge = json.load(f)

# 转换为文本
documents = []
for category, content in knowledge.items():
    text = json.dumps(content, ensure_ascii=False, indent=2)
    documents.append(text)

# 分割文本
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
splits = text_splitter.create_documents(documents)

# 创建向量数据库
vectorstore = Chroma.from_documents(
    documents=splits,
    embedding=embeddings,
    persist_directory="./chroma_db"
)

# 创建检索QA链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 3})
)

# 使用
response = qa_chain.run("OmniWatch Pro的价格是多少？")
print(response)

方法2：LoRA微调（高级）

如果需要深度定制，可以使用LoRA进行参数高效微调：

from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, TaskType
from datasets import load_dataset

# 加载基础模型
model_id = "Qwen/Qwen2.5-7B"  # 使用较小版本进行微调
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_id)

# LoRA配置
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,
    lora_alpha=32,
    lora_dropout=0.1,
    target_modules=["q_proj", "v_proj"]
)

# 应用LoRA
model = get_peft_model(model, lora_config)

# 加载数据
dataset = load_dataset("json", data_files="knowledge-base/training-data.jsonl")

# 训练参数
training_args = TrainingArguments(
    output_dir="./qwen-omniverse",
    num_train_epochs=3,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=4,
    warmup_steps=100,
    logging_steps=10,
    save_strategy="epoch",
    evaluation_strategy="no",
    learning_rate=1e-4,
)

# 训练（需要GPU）
# trainer = Trainer(model=model, args=training_args, train_dataset=dataset)
# trainer.train()

LangChain集成

完整的聊天应用示例

import os
from langchain.llms import Ollama
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain.prompts import PromptTemplate

# 配置
os.environ["OLLAMA_HOST"] = "http://localhost:11434"

# 初始化LLM
llm = Ollama(
    model="qwen2.5:32b",
    temperature=0.7,
    num_predict=2048
)

# 自定义提示模板
template = """你是OmniVerse公司的智能健康顾问。请基于以下对话历史，专业友好地回答用户问题。

对话历史：
{history}

用户：{input}
助手："""

prompt = PromptTemplate(
    input_variables=["history", "input"],
    template=template
)

# 创建对话链
memory = ConversationBufferMemory()
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    prompt=prompt,
    verbose=True
)

# 使用示例
def chat():
    print("OmniVerse智能健康顾问已就绪，输入'退出'结束对话")
    while True:
        user_input = input("\n用户: ")
        if user_input.lower() in ['退出', 'exit', 'quit']:
            break
        
        response = conversation.predict(input=user_input)
        print(f"\n助手: {response}")

if __name__ == "__main__":
    chat()

性能优化

1. 量化优化

使用量化版本减少内存占用：

# 下载量化版本
ollama pull qwen2.5:32b-q4_0  # 4-bit量化
ollama pull qwen2.5:32b-q8_0  # 8-bit量化

2. 批处理优化

# 批量处理请求
import asyncio
from ollama import AsyncClient

async def batch_generate(prompts):
    client = AsyncClient()
    tasks = []
    
    for prompt in prompts:
        task = client.generate(
            model='qwen2.5:32b',
            prompt=prompt,
            stream=False
        )
        tasks.append(task)
    
    responses = await asyncio.gather(*tasks)
    return responses

# 使用
prompts = [
    "介绍智能手表",
    "养老解决方案",
    "数据安全措施"
]
results = asyncio.run(batch_generate(prompts))

3. 缓存策略

from functools import lru_cache
import hashlib

class CachedLLM:
    def __init__(self, llm):
        self.llm = llm
        self.cache = {}
    
    def generate(self, prompt):
        # 生成缓存键
        cache_key = hashlib.md5(prompt.encode()).hexdigest()
        
        # 检查缓存
        if cache_key in self.cache:
            return self.cache[cache_key]
        
        # 生成响应
        response = self.llm.generate(prompt)
        self.cache[cache_key] = response
        
        return response

4. 流式响应

import ollama

def stream_chat(prompt):
    stream = ollama.generate(
        model='qwen2.5:32b',
        prompt=prompt,
        stream=True
    )
    
    for chunk in stream:
        print(chunk['response'], end='', flush=True)

部署建议

开发环境

• 使用 Qwen2.5-7B 进行快速迭代
• 单机部署，使用CPU即可

测试环境

• 使用 Qwen2.5-14B
• 配置8GB+ GPU加速
• 启用响应缓存

生产环境

• 使用 Qwen2.5-32B 或量化版本
• 多GPU服务器部署
• 负载均衡 + 缓存层
• 监控响应时间和准确率

监控与维护

监控指标

import time
import psutil
import GPUtil

class ModelMonitor:
    def __init__(self):
        self.metrics = {
            'request_count': 0,
            'total_latency': 0,
            'error_count': 0
        }
    
    def log_request(self, latency, success=True):
        self.metrics['request_count'] += 1
        self.metrics['total_latency'] += latency
        if not success:
            self.metrics['error_count'] += 1
    
    def get_stats(self):
        avg_latency = self.metrics['total_latency'] / max(1, self.metrics['request_count'])
        
        # 系统资源
        cpu_percent = psutil.cpu_percent()
        memory = psutil.virtual_memory()
        
        # GPU资源（如果有）
        gpus = GPUtil.getGPUs()
        gpu_stats = []
        for gpu in gpus:
            gpu_stats.append({
                'name': gpu.name,
                'load': gpu.load * 100,
                'memory': gpu.memoryUtil * 100
            })
        
        return {
            'requests': self.metrics['request_count'],
            'avg_latency': avg_latency,
            'error_rate': self.metrics['error_count'] / max(1, self.metrics['request_count']),
            'cpu_usage': cpu_percent,
            'memory_usage': memory.percent,
            'gpu_stats': gpu_stats
        }

常见问题

Q1: Ollama服务无法启动

# 检查端口占用
lsof -i :11434

# 重启服务
killall ollama
ollama serve

Q2: 模型响应速度慢

• 使用量化版本
• 启用GPU加速
• 减少 num_predict 参数
• 实施缓存策略

Q3: 内存不足

# 使用更小的模型
ollama pull qwen2.5:7b

# 或使用量化版本
ollama pull qwen2.5:32b-q4_0

Q4: 如何更新知识库

1. 修改 scripts/prepare-knowledge-base.js
2. 重新生成数据：node scripts/prepare-knowledge-base.js
3. 重新创建向量数据库
4. 或更新Modelfile中的系统提示词

相关资源

• Qwen官方仓库
• Ollama文档
• LangChain文档
• OmniVerse API文档