# 核心代码片段 (1_data_prep.py)
def export_and_format_data(db_url, output_file):
    # ... (数据库连接和读取代码) ...
    for index, row in df.iterrows():
        input_text = f"科目：{row['p_subjects']}\n题目：{row['p_question']}\n\n"
        # ... (动态添加选项) ...
        
        output_text = f"【正确答案】：{row['p_answer']}\n"
        output_text += f"【详细解析】：{row['p_explanation'] or '暂无解析'}"
        
        formatted_data.append({
            "instruction": INSTRUCTION,
            "input": input_text.strip(),
            "output": output_text.strip()
        })
    # ... (写入 jsonl 文件) ...

# 核心代码片段 (3_inference.py)
# 1. 加载量化后的基础模型
model = AutoModelForCausalLM.from_pretrained(...) 
# 2. 注入 LoRA 适配器
model = PeftModel.from_pretrained(model, OUTPUT_DIR)
model.eval() # 切换到评估模式
# 3. 构造与训练时完全一致的 Prompt 进行生成
prompt = f"### Instruction:\n{instruction}\n\n### Input:\n{input_text}\n\n### Response:\n"

import pandas as pd
from sqlalchemy import create_engine
import json
import os

# --- 配置 ---
# 数据库连接字符串：根据您的数据库类型修改
# 例如：SQLite: 'sqlite:///your_database_name.db'
# 例如：MySQL: 'mysql+pymysql://user:password@host/db_name'
DATABASE_URL = "sqlite:///everything.db" 
OUTPUT_FILE = "instruction_data.jsonl"
INSTRUCTION = "请根据提供的题目信息，给出正确答案以及详细的解析。"
# ----------------

def export_and_format_data(db_url, output_file):
    """从数据库读取题库，并格式化为指令微调所需的 JSONL 格式。"""
    
    print(f"尝试连接数据库：{db_url}")
    engine = create_engine(db_url)
    
    # 假设您的表名为 practice_questions
    df = pd.read_sql("SELECT * FROM practice_questions", engine)
    print(f"成功读取 {len(df)} 条题目数据。")
    
    formatted_data = []
    
    for index, row in df.iterrows():
        # 1. 构建 INPUT 字段 (包含所有题目和选项信息)
        input_text = f"科目：{row['p_subjects']}\n"
        input_text += f"类型：{row['p_type']}\n"
        input_text += f"章节：{row['p_chapter'] or 'N/A'}\n"
        input_text += f"题目：{row['p_question']}\n\n"
        
        # 动态添加选项，处理可能的 None/NaN 值
        options = {
            'A': row.get('p_option_a'), 'B': row.get('p_option_b'),
            'C': row.get('p_option_c'), 'D': row.get('p_option_d'),
            'E': row.get('p_option_e'), 'F': row.get('p_option_f'),
            'G': row.get('p_option_g'),
        }
        
        valid_options = [f"选项{k}：{v}" for k, v in options.items() if pd.notna(v) and v is not None]
        input_text += "\n".join(valid_options)
        
        # 2. 构建 OUTPUT 字段 (标准答案和解析)
        output_text = f"【正确答案】：{row['p_answer']}\n"
        output_text += f"【详细解析】：{row['p_explanation'] or '暂无解析'}"
        
        # 3. 构造最终的 JSON 格式
        formatted_data.append({
            "instruction": INSTRUCTION,
            "input": input_text.strip(),
            "output": output_text.strip()
        })

    # 将数据写入 JSONL 文件
    with open(output_file, 'w', encoding='utf-8') as f:
        for item in formatted_data:
            f.write(json.dumps(item, ensure_ascii=False) + '\n')

    print(f"\n数据格式化完成，已保存到 {output_file}，共 {len(formatted_data)} 条记录。")

if __name__ == "__main__":
    # 在运行前，请确保您已修改 DATABASE_URL 
    export_and_format_data(DATABASE_URL, OUTPUT_FILE)

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    Trainer,
    BitsAndBytesConfig,
)
from datasets import load_dataset
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# --- 基础参数 ---
BASE_MODEL = "Qwen/Qwen1.5-1.8B-Chat"   # ✅ 改用轻量版
DATA_PATH = "instruction_data.jsonl"
OUTPUT_DIR = "./qwen1.5_1.8b_lora"

# LoRA 参数
LORA_R = 16
LORA_ALPHA = 32
LORA_DROPOUT = 0.05

# 关键显存优化参数
MAX_LENGTH = 384  # ✅ 再次降低序列长度
MAX_VRAM_GB = 5.5

# ----------------------------------------------------
# 1. 数据预处理
# ----------------------------------------------------

def format_prompt(sample):
    text = f"### Instruction:\n{sample['instruction']}\n\n### Input:\n{sample['input']}\n\n### Response:\n{sample['output']}"
    return {"text": text}

print("加载并格式化数据集...")
dataset = load_dataset("json", data_files=DATA_PATH)
dataset = dataset.map(format_prompt, batched=False)

dataset = dataset["train"].train_test_split(test_size=0.05)
train_data = dataset["train"]
val_data = dataset["test"]
print(f"训练集大小: {len(train_data)}, 验证集大小: {len(val_data)}")

# ----------------------------------------------------
# 2. 加载模型 (QLoRA)
# ----------------------------------------------------

print(f"正在加载基础模型: {BASE_MODEL} (4-bit 量化)...")

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)

max_memory = {
    0: f'{int(MAX_VRAM_GB * 1024)}MiB',
    'cpu': '30GiB',
}

model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL,
    quantization_config=bnb_config,
    device_map="auto",
    max_memory=max_memory,
    low_cpu_mem_usage=True,
)

tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
tokenizer.pad_token = tokenizer.eos_token

# ----------------------------------------------------
# 3. 分词与标签
# ----------------------------------------------------

def tokenize_function(sample):
    tokens = tokenizer(
        sample["text"],
        max_length=MAX_LENGTH,
        truncation=True,
        padding="max_length",
    )
    return {
        "input_ids": tokens["input_ids"],
        "attention_mask": tokens["attention_mask"],
        "labels": tokens["input_ids"].copy(),
    }

print("应用分词器...")
train_data = train_data.map(
    tokenize_function,
    batched=False,
    remove_columns=["text", "instruction", "input", "output"]
)
val_data = val_data.map(
    tokenize_function,
    batched=False,
    remove_columns=["text", "instruction", "input", "output"]
)

model = prepare_model_for_kbit_training(model)

lora_config = LoraConfig(
    r=LORA_R,
    lora_alpha=LORA_ALPHA,
    lora_dropout=LORA_DROPOUT,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=["q_proj", "v_proj"],
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# ----------------------------------------------------
# 4. 训练参数
# ----------------------------------------------------

training_args = TrainingArguments(
    output_dir=OUTPUT_DIR,
    per_device_train_batch_size=1,          # ✅ 单 batch，降低显存
    gradient_accumulation_steps=8,          # ✅ 梯度累积弥补小 batch
    learning_rate=2e-5,
    num_train_epochs=3,
    logging_steps=20,
    save_strategy="epoch",
    fp16=True,
    optim="paged_adamw_8bit",
    report_to="none",
    remove_unused_columns=False,
    gradient_checkpointing=False,           # ✅ 关闭以避免过度显存占用
)

# ----------------------------------------------------
# 5. 启动训练
# ----------------------------------------------------

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_data,
    eval_dataset=val_data,
    tokenizer=tokenizer,
)

trainer.train()

trainer.model.save_pretrained(OUTPUT_DIR)
tokenizer.save_pretrained(OUTPUT_DIR)

print("\n🎉 微调完成！模型与LoRA权重已保存到", OUTPUT_DIR)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import PeftModel

# --- 配置参数 (请确保与训练时的配置一致) ---
# 基础模型（Qwen/Qwen1.5-1.8B-Chat）
BASE_MODEL = "Qwen/Qwen1.5-1.8B-Chat"
# 训练结果保存目录（LoRA 权重）
OUTPUT_DIR = "./qwen1.5_1.8b_lora"

# ----------------------------------------------------
# 1. 模型加载配置
# ----------------------------------------------------

# 4-bit 量化配置（必须与训练时一致）
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True,
)

# 严格限制 VRAM 占用
MAX_VRAM_GB = 5.5
max_memory = {
    0: f'{int(MAX_VRAM_GB * 1024)}MiB',
    'cpu': '30GiB'
}

print(f"正在加载基础模型: {BASE_MODEL}...")

# 1. 加载基础模型（带量化）
# 注意：确保有足够的 GPU 内存
model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL,
    quantization_config=bnb_config,
    device_map="auto",
    max_memory=max_memory,
    low_cpu_mem_usage=True,
)

# 2. 加载 LoRA 适配器权重
print(f"正在加载 LoRA 权重: {OUTPUT_DIR}...")
model = PeftModel.from_pretrained(model, OUTPUT_DIR)
model.eval() # 切换到评估模式

# 3. 加载分词器
tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
tokenizer.pad_token = tokenizer.eos_token

print("模型和 LoRA 权重加载完成。")

# ----------------------------------------------------
# 2. 推理/测试函数
# ----------------------------------------------------

def generate_response(instruction, input_text=""):
    """
    根据指令和输入生成模型的响应。
    请确保 prompt 格式与训练时使用的 `format_prompt` 一致。
    """
    
    # !!! 警告：请检查并修改 Qwen 模型实际使用的 Prompt 格式 !!!
    # 当前格式: 
    prompt = f"### Instruction:\n{instruction}\n\n### Input:\n{input_text}\n\n### Response:\n"
    
    # 编码输入
    # 假设 CUDA 可用
    device = "cuda" if torch.cuda.is_available() else "cpu"
    inputs = tokenizer(prompt, return_tensors="pt", truncation=True).to(device)

    # 生成设置
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=256,         # 最大生成长度
            do_sample=True,             # 启用采样（更自然的文本）
            top_p=0.9,                  # Top-p 采样
            temperature=0.7,            # 温度
            pad_token_id=tokenizer.eos_token_id 
        )

    # 解码结果并清理
    response_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
    
    # 提取实际的 Response 部分
    try:
        # 找到 ### Response: 之后的内容
        start_index = response_text.index("### Response:\n") + len("### Response:\n")
        response = response_text[start_index:].strip()
    except ValueError:
        # 如果模型没有严格遵循格式，则返回整个解码结果
        response = response_text.strip()
        
    return response

# ----------------------------------------------------
# 3. 交互式测试循环
# ----------------------------------------------------

print("\n--- 启动交互式测试（输入 'exit' 或 'quit' 结束） ---")

while True:
    # 接收指令
    user_instruction = input("\n[请输指令 (或 exit/quit 退出)]: ").strip()
    
    # 检查退出指令
    if user_instruction.lower() in ['exit', 'quit']:
        print("--- 退出交互式测试 ---")
        break
        
    # 接收可选的输入文本
    user_input = input("[请输 Input 文本 (可选，直接回车跳过)]: ").strip()
    
    print("--- 正在生成响应... ---")
    
    try:
        # 生成响应
        response = generate_response(user_instruction, user_input)
        
        # 打印结果
        print("\n**模型响应:**")
        print("=" * 20)
        print(response)
        print("=" * 20)
        
    except Exception as e:
        print(f"\n[错误]: 在生成响应时发生错误：{e}")
        # 如果出现错误，继续循环而不是直接退出

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

# --- 配置参数 (请确保与训练时的配置一致) ---
BASE_MODEL = "Qwen/Qwen1.5-1.8B-Chat" 
LORA_DIR = "./qwen1.5_1.8b_lora" 
MERGED_OUTPUT_DIR = "./qwen1.5_1.8b_merged"
# ----------------------------------------------------

print(f"--- 1. 正在加载基础模型: {BASE_MODEL} (非量化) ---")
# ⚠️ 注意：合并时需要加载基础模型为全精度 (torch.float16)，否则会导致精度丢失！
model = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL,
    torch_dtype=torch.float16,
    device_map="auto",
    low_cpu_mem_usage=True,
    # 合并时不需要量化配置
)
tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)

print(f"--- 2. 正在加载 LoRA 权重: {LORA_DIR} ---")
# 使用 PeftModel 包装基础模型
model = PeftModel.from_pretrained(model, LORA_DIR)

print("--- 3. 正在执行 LoRA 权重合并 (Merge and Unload) ---")
# 核心操作：将 LoRA 权重合并到基础模型的权重中，并移除 PeftModel 包装
# 合并后的模型将是全精度 (float16)
merged_model = model.merge_and_unload()

print(f"--- 4. 正在保存合并后的模型到: {MERGED_OUTPUT_DIR} ---")
# 保存全量的合并模型（包含所有微调效果）
merged_model.save_pretrained(MERGED_OUTPUT_DIR)
tokenizer.save_pretrained(MERGED_OUTPUT_DIR)

print("\n🎉 模型合并完成！现在您可以使用这个目录部署您的专家模型了。")
print(f"合并后的模型已保存到：{MERGED_OUTPUT_DIR}")