# 评估集格式示例
eval_dataset = [
    {
        "id": "eval_001",
        "question": "我们公司的年假政策是什么？",
        "reference_answer": "根据公司政策，工作满1年享有5天年假，满3年10天，满5年15天。",
        "category": "HR政策",
        "difficulty": "easy"
    },
    {
        "id": "eval_002",
        "question": "请帮我写一封拒绝供应商报价的邮件，语气要委婉",
        "reference_answer": "感谢贵方提供的报价方案...",  # 参考答案
        "category": "邮件写作",
        "difficulty": "medium"
    },
    # ... 至少50条
]

# 批量生成对比输出，方便人工评估
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
import json

def generate_comparison(questions, base_model_name, finetuned_model_path):
    """生成基础模型和微调模型的对比输出"""
    results = []

    # 加载两个模型
    base_tokenizer = AutoTokenizer.from_pretrained(base_model_name)
    base_model = AutoModelForCausalLM.from_pretrained(
        base_model_name, torch_dtype=torch.float16, device_map="auto"
    )

    ft_tokenizer = AutoTokenizer.from_pretrained(finetuned_model_path)
    ft_model = AutoModelForCausalLM.from_pretrained(
        finetuned_model_path, torch_dtype=torch.float16, device_map="auto"
    )

    for q in questions:
        # 基础模型输出
        base_input = base_tokenizer(q, return_tensors="pt").to(base_model.device)
        base_output = base_model.generate(**base_input, max_new_tokens=200, temperature=0.1)
        base_response = base_tokenizer.decode(base_output[0], skip_special_tokens=True)

        # 微调模型输出
        ft_input = ft_tokenizer(q, return_tensors="pt").to(ft_model.device)
        ft_output = ft_model.generate(**ft_input, max_new_tokens=200, temperature=0.1)
        ft_response = ft_tokenizer.decode(ft_output[0], skip_special_tokens=True)

        results.append({
            "question": q,
            "base_model": base_response,
            "finetuned_model": ft_response,
            "human_score_base": None,    # 人工填写
            "human_score_ft": None,      # 人工填写
            "notes": ""
        })

    # 保存为JSON，方便人工评分
    with open("comparison_results.json", "w", encoding="utf-8") as f:
        json.dump(results, f, ensure_ascii=False, indent=2)

    print(f"对比结果已保存到 comparison_results.json，请人工打分")
    return results

# pip install openai
from openai import OpenAI
import json
from typing import List, Dict

client = OpenAI()

def llm_evaluate_batch(eval_cases: List[Dict]) -> List[Dict]:
    """
    批量用 LLM 评估模型输出

    eval_cases 格式：
    [{"question": "...", "reference": "...", "response": "..."}, ...]
    """
    results = []

    for case in eval_cases:
        prompt = f"""你是一个专业的AI输出质量评估员。

请评估以下AI助手的回答质量。

【用户问题】
{case['question']}

【参考答案（标准答案）】
{case['reference']}

【AI回答（待评估）】
{case['response']}

请从以下维度评分（每项1-10分）：
1. 准确性：回答是否与参考答案一致，有无事实错误
2. 完整性：是否覆盖了参考答案的关键信息
3. 表达质量：语言是否清晰、流畅、专业

以JSON格式返回，不要有其他文字：
{{"accuracy": 8, "completeness": 7, "quality": 9, "overall": 8, "reason": "简要说明评分理由"}}"""

        resp = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            response_format={"type": "json_object"},
            temperature=0  # 评估要稳定，用temperature=0
        )

        scores = json.loads(resp.choices[0].message.content)
        results.append({
            **case,
            "scores": scores
        })

    return results


def summarize_evaluation(results: List[Dict]) -> Dict:
    """汇总评估结果，计算平均分"""
    if not results:
        return {}

    metrics = ["accuracy", "completeness", "quality", "overall"]
    summary = {}

    for metric in metrics:
        scores = [r["scores"][metric] for r in results if metric in r.get("scores", {})]
        if scores:
            summary[f"avg_{metric}"] = sum(scores) / len(scores)

    summary["total_cases"] = len(results)
    summary["pass_rate"] = sum(1 for r in results if r.get("scores", {}).get("overall", 0) >= 7) / len(results)

    return summary


# 使用示例
eval_cases = [
    {
        "question": "我们公司的年假政策是什么？",
        "reference": "工作满1年5天，满3年10天，满5年15天",
        "response": "根据公司规定，入职满一年后可享有5天带薪年假..."
    },
    # ... 更多测试案例
]

results = llm_evaluate_batch(eval_cases)
summary = summarize_evaluation(results)
print(f"平均综合分：{summary['avg_overall']:.1f}/10")
print(f"通过率（7分以上）：{summary['pass_rate']:.1%}")

# pip install rouge-score jieba
import jieba
from rouge_score import rouge_scorer

def evaluate_rouge_chinese(predictions: list, references: list) -> dict:
    """
    中文 ROUGE 评估

    注意：必须先用 jieba 分词，否则结果不准确
    ROUGE 是为英文设计的，中文需要先分词才能正确计算词重叠率
    """
    scorer = rouge_scorer.RougeScorer(
        ['rouge1', 'rouge2', 'rougeL'],
        tokenizer=None  # 我们自己处理分词
    )

    all_scores = {"rouge1": [], "rouge2": [], "rougeL": []}

    for pred, ref in zip(predictions, references):
        # 用 jieba 分词，用空格连接（让 rouge_score 按空格切分）
        pred_tokenized = " ".join(jieba.cut(pred))
        ref_tokenized = " ".join(jieba.cut(ref))

        score = scorer.score(ref_tokenized, pred_tokenized)
        all_scores["rouge1"].append(score["rouge1"].fmeasure)
        all_scores["rouge2"].append(score["rouge2"].fmeasure)
        all_scores["rougeL"].append(score["rougeL"].fmeasure)

    return {
        "rouge1": sum(all_scores["rouge1"]) / len(all_scores["rouge1"]),
        "rouge2": sum(all_scores["rouge2"]) / len(all_scores["rouge2"]),
        "rougeL": sum(all_scores["rougeL"]) / len(all_scores["rougeL"]),
    }


# ROUGE 分数参考基准（摘要任务）
# ROUGE-L > 0.4：较好
# ROUGE-L > 0.5：很好
# ROUGE-L > 0.6：优秀
# 注意：不同任务的基准不同，这里是摘要任务的参考值

用户请求
    ↓
流量分配（50% vs 50%）
    ├── A组：基础模型（对照组）
    └── B组：微调模型（实验组）
    ↓
收集用户反馈
    ├── 显式反馈：点赞/点踩
    └── 隐式反馈：对话轮数、任务完成率
    ↓
统计分析（至少运行1-2周，收集足够样本）
    ↓
决策：全量切换 / 继续迭代 / 回滚

# 简单的A/B测试统计显著性检验
from scipy import stats

def ab_test_significance(a_successes, a_total, b_successes, b_total):
    """
    检验A/B测试结果是否统计显著

    a_successes: A组成功数（如点赞数）
    a_total: A组总样本数
    b_successes: B组成功数
    b_total: B组总样本数
    """
    a_rate = a_successes / a_total
    b_rate = b_successes / b_total

    # 使用卡方检验
    contingency_table = [
        [a_successes, a_total - a_successes],
        [b_successes, b_total - b_successes]
    ]
    chi2, p_value, dof, expected = stats.chi2_contingency(contingency_table)

    print(f"A组满意率: {a_rate:.1%}")
    print(f"B组满意率: {b_rate:.1%}")
    print(f"差异: {(b_rate - a_rate):.1%}")
    print(f"p值: {p_value:.4f}")

    if p_value < 0.05:
        if b_rate > a_rate:
            print("✅ 结论：B组（微调模型）显著优于A组，建议全量切换")
        else:
            print("❌ 结论：B组（微调模型）显著差于A组，建议回滚")
    else:
        print("⚠️ 结论：差异不显著（p > 0.05），需要更多样本或继续观察")

# 示例
ab_test_significance(
    a_successes=180, a_total=300,   # A组：300次，180次满意
    b_successes=225, b_total=300    # B组：300次，225次满意
)

# 第1步：合并 LoRA 权重（如果用了 LoRA 微调）
# 在 Python 中执行：
# from peft import AutoPeftModelForCausalLM
# model = AutoPeftModelForCausalLM.from_pretrained("./lora-output")
# merged = model.merge_and_unload()
# merged.save_pretrained("./merged-model")

# 第2步：转换为 GGUF 格式（llama.cpp 支持的格式）
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make
python convert_hf_to_gguf.py ../merged-model --outfile ../model.gguf --outtype f16

# 第3步：量化（可选，减小文件体积）
./quantize ../model.gguf ../model-q4_k_m.gguf Q4_K_M

# 第4步：创建 Ollama 模型
# 先写 Modelfile
cat > Modelfile << 'EOF'
FROM ./model-q4_k_m.gguf

# 系统提示词（根据你的微调任务修改）
SYSTEM """你是一个专业的企业内部助手，熟悉公司的政策和流程。
请用简洁、专业的语言回答员工的问题。"""

# 推理参数
PARAMETER temperature 0.1
PARAMETER top_p 0.9
PARAMETER num_ctx 4096
EOF

ollama create my-assistant -f Modelfile
ollama run my-assistant "我们公司的年假政策是什么？"

# 安装 vLLM
pip install vllm

# 启动 OpenAI 兼容的 API 服务
python -m vllm.entrypoints.openai.api_server \
    --model ./merged-model \
    --port 8000 \
    --max-model-len 4096 \
    --gpu-memory-utilization 0.9

# 调用方式和 OpenAI API 完全兼容
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"  # vLLM 本地部署不需要真实 API key
)

response = client.chat.completions.create(
    model="./merged-model",
    messages=[
        {"role": "system", "content": "你是一个专业的企业内部助手"},
        {"role": "user", "content": "我们公司的年假政策是什么？"}
    ],
    temperature=0.1,
    max_tokens=500
)

print(response.choices[0].message.content)

训练完成
    ↓
【第1步】人工评估（20-30个case）
    ├── 平均分 < 3.5 → 检查训练数据，重新微调
    └── 平均分 ≥ 3.5 → 继续
    ↓
【第2步】LLM 自动评估（50+ case）
    ├── 综合分 < 6.0 → 补充训练数据，重新微调
    └── 综合分 ≥ 6.0 → 继续
    ↓
【第3步】灾难遗忘检测（通用能力测试）
    ├── 通用能力明显下降 → 混入通用数据，重新微调
    └── 通用能力正常 → 继续
    ↓
【第4步】小流量 A/B 测试（10%流量，1周）
    ├── 用户满意度下降 → 回滚
    └── 用户满意度持平或提升 → 继续
    ↓
【第5步】全量上线 + 持续监控

数据准备 → 微调训练 → 人工评估 → LLM自动评估 → A/B测试 → 全量上线 → 持续迭代