📅 更新于 2026-05-29 | OpenClawLLM-as-Judge评估

⚖️ LLM-as-Judge 详解

📖 什么是 LLM-as-Judge？

LLM-as-Judge（LLM裁判/LLM评估）是指使用大型语言模型（LLM）作为评估器，对另一个AI系统的输出进行质量评估、打分或比较。它解决了传统评估方法（人工、规则）的瓶颈：成本高、速度慢、难以规模化。

核心思想：用一个强大的LLM（如Claude、GPT-4）来评估另一个模型或Agent的输出质量。

🧠 核心原理

1. 评估方式

2. 评估Prompt设计

好的评估Prompt是关键：

评估Prompt模板：
你是一个专业的内容评估师。请对以下内容进行评分。

评估维度：
1. 内容质量（信息密度、准确性）：0-5分
2. 风格匹配（是否符合妙趣风格）：0-5分
3. 实用性（可操作性）：0-5分
4. SEO优化：0-5分
5. 创新性：0-5分

内容：
{{CONTENT}}

请按以下格式输出：
{
  "quality": 4.5,
  "style": 4.0,
  "utility": 5.0,
  "seo": 3.5,
  "innovation": 4.0,
  "overall": 4.2,
  "reason": "风格到位，代码示例清晰..."
}

3. 可靠性问题

LLM-as-Judge的局限性：

• 位置偏差：倾向于给第一个选项高分
• 长度偏差：倾向于给更长的内容高分
• 自我偏好：倾向于给和自己风格相似的内容高分
• 不一致性：同样的内容，多次评估可能得分不同

🛠️ OpenClaw 实战应用

场景一：妙趣AI五维评分

妙趣AI使用LLM-as-Judge实现五维评分：

# 妙趣AI 内容评估
async function evaluateContent(content, channel) {
  const prompt = `
你是一个专业的内容评估师，擅长评估"妙趣风格"内容。
妙趣风格：王家卫时间感 + 周星驰脑洞 + 技术拆解。

请对以下内容进行评估（0-5分）：
1. 内容质量：信息密度、准确性、深度
2. 风格匹配：是否符合妙趣风格
3. 实用性：可操作性、对读者的价值
4. SEO优化：关键词、结构、可读性
5. AI味检测：是否像AI生成（越低越好，2.0以下为优）

内容：
${content}

输出JSON格式：
{
  "quality": 4.5,
  "style": 4.0,
  "utility": 5.0,
  "seo": 3.5,
  "ai_smell": 1.5,
  "overall": 4.2,
  "passed": true,
  "reason": "..."
}
`;
  
  const evaluation = await llm.call(prompt);
  return JSON.parse(evaluation);
}

// 使用
const content = await generateArticle();
const score = await evaluateContent(content, 'website');

if (score.passed) {
  await publish(content);
} else {
  console.log(`内容未通过：${score.reason}`);
}

场景二：A/B测试两个版本

# 比较两个标题哪个更好
async function compareTitles(titleA, titleB, context) {
  const prompt = `
请比较两个标题，选择更适合"妙趣AI"风格的一个。

标题A：${titleA}
标题B：${titleB}

上下文：${context}

评估标准：
1. 吸引力（点击率）
2. 风格匹配（妙趣风格）
3. 信息量（是否传达核心内容）

请输出：
{
  "winner": "A" 或 "B",
  "reason": "...",
  "scoreA": 4.0,
  "scoreB": 4.5
}
`;
  
  return await llm.call(prompt);
}

场景三：批量内容审核

妙趣AI每天生成大量内容，用LLM-as-Judge批量审核：

# 批量评估术语页面
const pages = await getAllGlossaryPages();
const results = [];

for (const page of pages) {
  const score = await evaluateContent(page.content, 'glossary');
  
  results.push({
    page: page.url,
    score: score.overall,
    passed: score.passed
  });
  
  // 如果质量太低，触发重新生成
  if (score.overall < 3.5) {
    await regeneratePage(page.term);
  }
}

// 输出评估报告
console.log(`评估完成：${results.length}个页面`);
console.log(`平均得分：${average(results.map(r => r.score))}`);

💻 代码示例

示例1：LLM Judge实现

// LLM-as-Judge 实现
class LLMJudge {
  constructor(llm) {
    this.llm = llm;
  }
  
  async judge(content, criteria) {
    const prompt = this.buildPrompt(content, criteria);
    const response = await this.llm.call(prompt);
    
    try {
      return JSON.parse(response);
    } catch (e) {
      // 解析失败，返回默认评分
      return { overall: 3.0, error: 'Parse error' };
    }
  }
  
  buildPrompt(content, criteria) {
    return `
你是一个专业的内容评估师。

评估标准：
${criteria.map((c, i) => `${i+1}. ${c.name}（${c.min}-${c.max}分）：${c.description}`).join('\n')}

待评估内容：
${content}

请输出JSON格式：
{
  ${criteria.map(c => `"${c.key}": ${c.exampleScore},`).join('\n  ')}
  "overall": 4.0,
  "reason": "评估理由..."
}
`;
  }
  
  // 比较两个内容
  async compare(contentA, contentB, criteria) {
    const prompt = `
请比较两个内容，选择更好的一个。

内容A：
${contentA}

内容B：
${contentB}

评估标准：${criteria.map(c => c.name).join(', ')}

输出JSON：
{
  "winner": "A" 或 "B",
  "reason": "...",
  "scoreA": 4.0,
  "scoreB": 4.5
}
`;
    
    return await this.llm.call(prompt);
  }
}

// 使用
const judge = new LLMJudge(claude);
const score = await judge.judge(article, [
  { name: '质量', key: 'quality', min: 0, max: 5, exampleScore: 4.0 },
  { name: '风格', key: 'style', min: 0, max: 5, exampleScore: 4.5 }
]);

示例2：减少位置偏差

// 减少LLM Judge的位置偏差
async function unbiasedCompare(contentA, contentB, criteria) {
  // 随机交换位置，运行两次
  const order1 = Math.random() > 0.5 ? [contentA, contentB] : [contentB, contentA];
  
  const result1 = await judge.compare(order1[0], order1[1], criteria);
  
  // 如果A在第一次是winner，计算A的得分
  const scoreA = result1.winner === 'A' ? result1.scoreA : result1.scoreB;
  const scoreB = result1.winner === 'A' ? result1.scoreB : result1.scoreA;
  
  // 如果得分接近，再跑一次（交换位置）
  if (Math.abs(scoreA - scoreB) < 0.5) {
    const order2 = [order1[1], order1[0]];  // 交换
    const result2 = await judge.compare(order2[0], order2[1], criteria);
    
    // 综合两次结果
    return {
      winner: scoreA > scoreB ? 'A' : 'B',
      confidence: Math.abs(scoreA - scoreB)
    };
  }
  
  return { winner: scoreA > scoreB ? 'A' : 'B', confidence: Math.abs(scoreA - scoreB) };
}

示例3：妙趣AI评估配置

# openclaw.yaml - LLM Judge配置
evaluation:
  judge:
    model: "claude-sonnet-4"  # 裁判模型（通常比生成模型强）
    temperature: 0.1  # 低温度，保证一致性
  
  criteria:
    - name: "内容质量"
      key: "quality"
      weight: 0.3
      min: 0
      max: 5
    
    - name: "妙趣风格"
      key: "style"
      weight: 0.25
      min: 0
      max: 5
    
    - name: "实用性"
      key: "utility"
      weight: 0.2
      min: 0
      max: 5
    
    - name: "SEO优化"
      key: "seo"
      weight: 0.15
      min: 0
      max: 5
    
    - name: "创新性"
      key: "innovation"
      weight: 0.1
      min: 0
      max: 5
  
  # 通过阈值
  passThreshold: 4.0
  
  # 自动重新生成阈值
  regenerateThreshold: 3.5

✅ 最佳实践

📊 评估方法对比

🎬 周星驰式总结

就像《唐伯虎点秋香》里的"考官"——表面上是AI在给AI打分，实际上是人类价值观的延伸。LLM-as-Judge就是让AI当"助教"，帮人类快速筛选优质内容。记住：裁判也是人（哦不，是AI），也会有偏见，要多跑几次取平均！

🔗 相关链接

• Agent Evaluation Benchmark 详解
• AI Evals 详解
• Human-in-the-Loop 详解
• Judging LLM-as-a-Judge 论文