三模型同台竞技实战教程：GLM-5.2 vs Kimi 2.7 Code vs Opus 4.8，用 Gemini 3.1 Pro 做裁判，手把手教你科学评测大模型真实能力 - 微元算力(weytok

m0_37841076

394人浏览 · 2026-06-18 11:20:28

m0_37841076 · 2026-06-18 11:20:28 发布

摘要

“这个大模型真的比那个强吗？”——这是每一位AI应用开发者都会反复问自己的问题。看排行榜？看跑分？还是看朋友圈的截图？本文不跟你讲虚的，我们用一套严格可复现的科学评测方法，让 GLM-5.2、Kimi 2.7 Code、Opus 4.8 三个模型同台竞技，完成同一个真实开发任务——从零构建一个单文件HTML网页Excel数据分析与可视化工具。再由 Gemini 3.1 Pro 作为独立裁判模型，从三个维度进行量化打分，最终给出公正排名。全文代码完整可运行，建议收藏后实操。

一、教程目标与环境准备
二、设计Agent测试任务（提示词工程）
三、调用GLM-5.2（含完整代码）
四、调用Kimi 2.7 Code（含完整代码）
五、调用Opus 4.8（含完整代码）
六、裁判模型打分系统（Gemini-3.1-Pro裁判，含完整代码）
七、结果汇总与分析
八、构建自动化评测流水线
九、总结

一、教程目标与环境准备

1.1 我们要做什么

本教程将带你完成一次完整的科学大模型能力评测实验，具体流程如下：

┌──────────────┐    ┌──────────────┐    ┌──────────────┐
│   GLM-5.2    │    │ Kimi 2.7 Code│    │   Opus 4.8   │
│  (智谱AI)    │    │ (Moonshot)   │    │ (Anthropic)  │
└──────┬───────┘    └──────┬───────┘    └──────┬───────┘
       │                   │                   │
       ▼                   ▼                   ▼
  ┌─────────────────────────────────────────────────┐
  │         同一套测试任务（Prompt Engineering）       │
  │   "开发单文件HTML网页Excel数据分析与可视化工具"    │
  └─────────────────────────────────────────────────┘
       │                   │                   │
       ▼                   ▼                   ▼
  ┌──────────┐      ┌──────────┐      ┌──────────┐
  │ 代码产出A │      │ 代码产出B │      │ 代码产出C │
  └────┬─────┘      └────┬─────┘      └────┬─────┘
       │                 │                 │
       └─────────┬───────┴─────────┬───────┘
                 │                 │
                 ▼                 ▼
        ┌─────────────────────────────────┐
        │   Gemini 3.1 Pro 裁判模型打分    │
        │  · 代码质量与可运行性 (40分)      │
        │  · 功能完整性与用户体验 (35分)    │
        │  · 创新性与工程实践 (25分)        │
        └─────────────────────────────────┘
                         │
                         ▼
                ┌─────────────────┐
                │   最终排名与报告  │
                └─────────────────┘

1.2 环境准备

你需要安装以下Python依赖：

pip install openai anthropic google-generativeai

关于统一API接入：如果你希望在一个平台上统一接入多个大模型，而不是分别对接各家的SDK，可以使用 微元算力(weytoken) 这样的企业级大模型API聚合平台，它提供统一的 OpenAI 兼容接口，通过 base_url="https://api.weytoken.com/v1" 即可调用 GLM、Kimi、Opus 等数十种模型，省去分别对接各家API的繁琐工作，同时支持数据安全审计和企业合规功能。

1.3 项目结构

evaluation/
├── task_prompt.txt           # 统一的测试任务提示词
├── glm52_generate.py         # 调用GLM-5.2生成代码
├── kimi27_generate.py        # 调用Kimi 2.7 Code生成代码
├── opus48_generate.py        # 调用Opus 4.8生成代码
├── judge_scoring.py          # 裁判模型打分脚本
├── pipeline.py               # 自动化评测流水线
├── outputs/
│   ├── glm52_result.html     # GLM-5.2生成结果
│   ├── kimi27_result.html    # Kimi 2.7 Code生成结果
│   └── opus48_result.html    # Opus 4.8生成结果
└── report.json               # 最终评测报告

二、设计Agent测试任务（提示词工程）

2.1 任务设计原则

一个好的评测任务需要满足三个条件：

真实性：模拟真实开发场景，而非玩具级别的算法题
可量化：产生的结果可以被客观评估
有区分度：不同水平的模型能拉开差距

基于以上原则，我们设计了一个单文件HTML网页Excel数据分析与可视化工具的完整开发任务。这个任务要求模型同时具备：前端工程能力（HTML/CSS/JS）、数据处理能力（SheetJS）、可视化能力（ECharts）、以及中文技术写作能力（分析报告）。

2.2 完整提示词

以下是我们提供给三个模型的统一提示词（task_prompt.txt）：

你是一名资深全栈工程师。请开发一个**单文件HTML网页应用**，实现Excel数据分析与可视化工具。

## 功能要求

### 核心功能
1. **文件上传与解析**：支持上传 .xlsx 和 .xls 文件，使用 SheetJS (xlsx.js) CDN 库进行解析
2. **多Sheet支持**：如果Excel包含多个Sheet，提供Sheet切换标签页
3. **数据表格展示**：
   - 支持搜索/筛选功能（全局搜索框）
   - 支持分页展示（每页20条，带页码导航）
   - 支持横向滚动（数据列较多时）
4. **字段类型自动识别**：自动判断每列的数据类型（数值、日期、文本、布尔等），并在表头下方显示类型标签
5. **数据统计面板**：
   - 总行数、总列数
   - 每列的缺失值数量
   - 每列的唯一值数量
   - 数值列的最大值、最小值、平均值、求和
6. **中文分析报告**：自动生成一份中文数据分析摘要报告，包含数据质量评估、关键发现等
7. **ECharts可视化图表**：
   - 用户可自定义选择X轴字段和Y轴字段
   - 支持多种图表类型：柱状图、折线图、饼图、散点图
   - 图表可交互

### 技术要求
- 纯单文件HTML，所有CSS和JS内联
- 外部依赖通过CDN引入（SheetJS、ECharts）
- 界面美观，使用现代化的UI设计
- 代码结构清晰，注释完整
- 响应式布局，适配不同屏幕尺寸

## 输出格式
请直接输出完整的HTML文件代码，不要包含任何解释性文字。代码以 ```html 开头。

三、调用GLM-5.2（含完整代码）

3.1 GLM-5.2 简介

GLM-5.2 是智谱AI推出的新一代大语言模型，在代码生成和逻辑推理方面有显著提升。它支持通过 OpenAI 兼容接口调用，这为统一接入提供了极大便利。

3.2 完整调用代码

创建文件 glm52_generate.py：

"""
GLM-5.2 代码生成脚本
通过 OpenAI 兼容接口调用 GLM-5.2 模型
"""

import os
import re
from openai import OpenAI

# ============ 配置区 ============
# 方式一：使用智谱AI官方API
# API_KEY = "your-zhipu-api-key"
# BASE_URL = "https://open.bigmodel.cn/api/paas/v4/"

# 方式二：使用微元算力统一API接入（推荐）
# 通过企业级聚合平台统一接入，支持数据安全审计和企业合规
API_KEY = "your-weytoken-api-key"
BASE_URL = "https://api.weytoken.com/v1"

MODEL_NAME = "glm-5.2"  # 模型名称按平台实际标识调整

OUTPUT_DIR = "outputs"
OUTPUT_FILE = os.path.join(OUTPUT_DIR, "glm52_result.html")
# ================================


def load_prompt(filepath="task_prompt.txt"):
    """加载测试任务提示词"""
    with open(filepath, "r", encoding="utf-8") as f:
        return f.read()


def extract_html_code(response_text: str) -> str:
    """从模型响应中提取HTML代码块"""
    # 匹配 ```html ... ```代码块
    pattern = r'```html\s*\n(.*?)```'
    match = re.search(pattern, response_text, re.DOTALL)
    if match:
        return match.group(1).strip()

    # 如果没有代码块标记，尝试提取完整的HTML文档
    html_pattern = r'(<!DOCTYPE html>.*?</html>)'
    match = re.search(html_pattern, response_text, re.DOTALL | re.IGNORECASE)
    if match:
        return match.group(1).strip()

    return response_text.strip()


def call_glm52(prompt: str) -> str:
    """调用GLM-5.2模型生成代码"""
    client = OpenAI(
        api_key=API_KEY,
        base_url=BASE_URL,
    )

    print(f"[GLM-5.2] 正在调用模型: {MODEL_NAME}")
    print(f"[GLM-5.2] API接入点: {BASE_URL}")

    response = client.chat.completions.create(
        model=MODEL_NAME,
        messages=[
            {
                "role": "system",
                "content": "你是一名资深全栈工程师，擅长HTML/CSS/JavaScript开发。请严格按照用户要求输出完整的代码。"
            },
            {
                "role": "user",
                "content": prompt
            }
        ],
        temperature=0.3,          # 较低温度以获得更稳定的代码输出
        max_tokens=16384,         # 足够大的token上限以容纳完整HTML
        top_p=0.95,
    )

    # 提取响应内容
    content = response.choices[0].message.content
    token_usage = response.usage

    print(f"[GLM-5.2] 生成完成")
    print(f"  - 输入Token: {token_usage.prompt_tokens}")
    print(f"  - 输出Token: {token_usage.completion_tokens}")
    print(f"  - 总Token: {token_usage.total_tokens}")

    return content


def main():
    """主流程"""
    # 1. 加载提示词
    print("=" * 60)
    print("GLM-5.2 代码生成评测")
    print("=" * 60)

    prompt = load_prompt()
    print(f"[INFO] 提示词长度: {len(prompt)} 字符")

    # 2. 调用模型生成代码
    raw_response = call_glm52(prompt)

    # 3. 提取HTML代码
    html_code = extract_html_code(raw_response)
    print(f"[INFO] 提取的HTML代码长度: {len(html_code)} 字符")

    # 4. 保存结果
    os.makedirs(OUTPUT_DIR, exist_ok=True)
    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
        f.write(html_code)

    print(f"[SUCCESS] 代码已保存至: {OUTPUT_FILE}")
    print("=" * 60)


if __name__ == "__main__":
    main()

3.3 运行说明

# 设置API Key（二选一）
# 智谱官方：
export ZHIPU_API_KEY="your-key"

# 微元算力统一接入：
export WEYTOKEN_API_KEY="your-key"

# 运行脚本
python glm52_generate.py

3.4 关键设计说明

温度参数设置为0.3：代码生成任务需要较低的随机性，确保输出稳定可靠
max_tokens设为16384：单文件HTML可能较长，需要足够的输出空间
代码提取正则：模型的输出可能包含额外的解释文字，需要用正则精确提取HTML代码块
统一接入兼容性：通过 OpenAI 兼容接口，同一套代码只需修改 base_url 和 model 即可切换不同厂商的模型，这也是 微元算力(weytoken) 这类聚合平台的核心价值——开发者无需学习多套SDK，一套代码走天下

四、调用Kimi 2.7 Code（含完整代码）

4.1 Kimi 2.7 Code 简介

Kimi 2.7 Code 是 Moonshot AI 推出的代码专用模型，在前端开发和代码生成任务上表现突出。它同样支持 OpenAI 兼容接口。

4.2 完整调用代码

创建文件 kimi27_generate.py：

"""
Kimi 2.7 Code 代码生成脚本
通过 Moonshot API (OpenAI兼容接口) 调用 Kimi 2.7 Code 模型
"""

import os
import re
import time
from openai import OpenAI

# ============ 配置区 ============
# 方式一：使用Moonshot官方API
# API_KEY = "your-moonshot-api-key"
# BASE_URL = "https://api.moonshot.cn/v1"

# 方式二：使用微元算力统一API接入
API_KEY = "your-weytoken-api-key"
BASE_URL = "https://api.weytoken.com/v1"

MODEL_NAME = "kimi-2.7-code"  # 模型名称按平台实际标识调整

OUTPUT_DIR = "outputs"
OUTPUT_FILE = os.path.join(OUTPUT_DIR, "kimi27_result.html")
# ================================


def load_prompt(filepath="task_prompt.txt"):
    """加载测试任务提示词"""
    with open(filepath, "r", encoding="utf-8") as f:
        return f.read()


def extract_html_code(response_text: str) -> str:
    """从模型响应中提取HTML代码块"""
    pattern = r'```html\s*\n(.*?)```'
    match = re.search(pattern, response_text, re.DOTALL)
    if match:
        return match.group(1).strip()

    html_pattern = r'(<!DOCTYPE html>.*?</html>)'
    match = re.search(html_pattern, response_text, re.DOTALL | re.IGNORECASE)
    if match:
        return match.group(1).strip()

    return response_text.strip()


def call_kimi27(prompt: str, max_retries: int = 3) -> str:
    """调用Kimi 2.7 Code模型生成代码（带重试机制）"""
    client = OpenAI(
        api_key=API_KEY,
        base_url=BASE_URL,
    )

    print(f"[Kimi 2.7 Code] 正在调用模型: {MODEL_NAME}")
    print(f"[Kimi 2.7 Code] API接入点: {BASE_URL}")

    for attempt in range(1, max_retries + 1):
        try:
            response = client.chat.completions.create(
                model=MODEL_NAME,
                messages=[
                    {
                        "role": "system",
                        "content": (
                            "你是 Kimi，一位精通前端开发的资深工程师。"
                            "请直接输出完整可运行的HTML代码，不要包含解释。"
                            "代码必须包含所有CSS和JS，外部库通过CDN引入。"
                        )
                    },
                    {
                        "role": "user",
                        "content": prompt
                    }
                ],
                temperature=0.2,          # 代码任务保持低温度
                max_tokens=16384,
                top_p=0.9,
            )

            content = response.choices[0].message.content
            token_usage = response.usage

            print(f"[Kimi 2.7 Code] 生成完成 (第{attempt}次尝试)")
            print(f"  - 输入Token: {token_usage.prompt_tokens}")
            print(f"  - 输出Token: {token_usage.completion_tokens}")
            print(f"  - 总Token: {token_usage.total_tokens}")

            return content

        except Exception as e:
            print(f"[Kimi 2.7 Code] 第{attempt}次调用失败: {e}")
            if attempt < max_retries:
                wait_time = 2 ** attempt
                print(f"[Kimi 2.7 Code] 等待{wait_time}秒后重试...")
                time.sleep(wait_time)
            else:
                raise RuntimeError(f"Kimi 2.7 Code 调用失败，已重试{max_retries}次") from e


def main():
    """主流程"""
    print("=" * 60)
    print("Kimi 2.7 Code 代码生成评测")
    print("=" * 60)

    # 1. 加载提示词
    prompt = load_prompt()
    print(f"[INFO] 提示词长度: {len(prompt)} 字符")

    # 2. 调用模型生成代码
    raw_response = call_kimi27(prompt)

    # 3. 提取HTML代码
    html_code = extract_html_code(raw_response)
    print(f"[INFO] 提取的HTML代码长度: {len(html_code)} 字符")

    # 4. 保存结果
    os.makedirs(OUTPUT_DIR, exist_ok=True)
    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
        f.write(html_code)

    print(f"[SUCCESS] 代码已保存至: {OUTPUT_FILE}")
    print("=" * 60)


if __name__ == "__main__":
    main()

4.3 与GLM-5.2调用的差异

对比维度	GLM-5.2	Kimi 2.7 Code
System Prompt	通用全栈工程师	强调前端开发专长
温度参数	0.3	0.2（更保守）
重试机制	无	3次指数退避重试
角色定位	全栈	前端专家

五、调用Opus 4.8（含完整代码）

5.1 Opus 4.8 简介

Opus 4.8 是 Anthropic 旗下的顶级模型，在复杂推理和代码生成方面表现卓越。本教程中使用 Anthropic 官方 Python SDK 进行调用，同时展示如何通过 OpenAI 兼容接口接入。

5.2 完整调用代码（方式一：Anthropic SDK）

创建文件 opus48_generate_anthropic.py：

"""
Opus 4.8 代码生成脚本 (Anthropic SDK)
使用 Anthropic 官方 Python SDK 调用 Opus 4.8 模型
"""

import os
import re
import time
from anthropic import Anthropic

# ============ 配置区 ============
API_KEY = "your-anthropic-api-key"
MODEL_NAME = "claude-opus-4-8-20250514"  # 按实际模型标识调整

OUTPUT_DIR = "outputs"
OUTPUT_FILE = os.path.join(OUTPUT_DIR, "opus48_result.html")
# ================================


def load_prompt(filepath="task_prompt.txt"):
    with open(filepath, "r", encoding="utf-8") as f:
        return f.read()


def extract_html_code(response_text: str) -> str:
    """从模型响应中提取HTML代码块"""
    pattern = r'```html\s*\n(.*?)```'
    match = re.search(pattern, response_text, re.DOTALL)
    if match:
        return match.group(1).strip()

    html_pattern = r'(<!DOCTYPE html>.*?</html>)'
    match = re.search(html_pattern, response_text, re.DOTALL | re.IGNORECASE)
    if match:
        return match.group(1).strip()

    return response_text.strip()


def call_opus48(prompt: str, max_retries: int = 3) -> str:
    """调用Opus 4.8模型生成代码"""
    client = Anthropic(api_key=API_KEY)

    print(f"[Opus 4.8] 正在调用模型: {MODEL_NAME}")

    for attempt in range(1, max_retries + 1):
        try:
            response = client.messages.create(
                model=MODEL_NAME,
                max_tokens=16384,
                temperature=0.25,
                system=(
                    "你是一位资深全栈工程师，精通HTML/CSS/JavaScript。"
                    "请严格按照用户要求输出完整的HTML代码，使用CDN引入外部依赖。"
                    "代码必须是一个完整的、可独立运行的HTML文件。"
                ),
                messages=[
                    {
                        "role": "user",
                        "content": prompt
                    }
                ],
            )

            content = response.content[0].text
            input_tokens = response.usage.input_tokens
            output_tokens = response.usage.output_tokens

            print(f"[Opus 4.8] 生成完成 (第{attempt}次尝试)")
            print(f"  - 输入Token: {input_tokens}")
            print(f"  - 输出Token: {output_tokens}")
            print(f"  - 总Token: {input_tokens + output_tokens}")

            return content

        except Exception as e:
            print(f"[Opus 4.8] 第{attempt}次调用失败: {e}")
            if attempt < max_retries:
                wait_time = 2 ** attempt
                print(f"[Opus 4.8] 等待{wait_time}秒后重试...")
                time.sleep(wait_time)
            else:
                raise RuntimeError(f"Opus 4.8 调用失败，已重试{max_retries}次") from e


def main():
    print("=" * 60)
    print("Opus 4.8 代码生成评测")
    print("=" * 60)

    prompt = load_prompt()
    print(f"[INFO] 提示词长度: {len(prompt)} 字符")

    raw_response = call_opus48(prompt)

    html_code = extract_html_code(raw_response)
    print(f"[INFO] 提取的HTML代码长度: {len(html_code)} 字符")

    os.makedirs(OUTPUT_DIR, exist_ok=True)
    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
        f.write(html_code)

    print(f"[SUCCESS] 代码已保存至: {OUTPUT_FILE}")
    print("=" * 60)


if __name__ == "__main__":
    main()

5.3 完整调用代码（方式二：OpenAI兼容接口）

如果你使用 微元算力(weytoken) 大模型API聚合平台，Opus 4.8 也可以通过统一接口调用：

"""
Opus 4.8 代码生成脚本 (OpenAI兼容接口)
通过微元算力统一API接入 Opus 4.8
"""

from openai import OpenAI

client = OpenAI(
    api_key="your-weytoken-api-key",
    base_url="https://api.weytoken.com/v1",
)

response = client.chat.completions.create(
    model="claude-opus-4-8",  # 按平台实际标识调整
    messages=[
        {"role": "system", "content": "你是一位资深全栈工程师。"},
        {"role": "user", "content": prompt}
    ],
    temperature=0.25,
    max_tokens=16384,
)

html_code = response.choices[0].message.content

技术提示：三种模型使用不同的SDK或接口，但本质上都是 HTTP API 调用。对于企业级多模型评测场景，使用统一接入平台可以大幅降低对接成本，同时满足数据安全隔离和合规审计的需求。

六、裁判模型打分系统（Gemini-3.1-Pro裁判，含完整代码）

6.1 裁判模型的选择

选择 Gemini 3.1 Pro 作为裁判模型，基于以下考虑：

中立性：Gemini 由 Google 开发，与三个参赛模型（智谱、Moonshot、Anthropic）均无利益关联
长文本理解能力：Gemini 3.1 Pro 拥有百万级上下文窗口，可以完整阅读三个模型的HTML代码输出
结构化输出能力：能够稳定输出JSON格式的评分结果

6.2 三个打分维度

维度	满分	评估要点
代码质量与可运行性	40分	代码结构清晰度、注释完整性、是否可正常运行、错误处理、命名规范
功能完整性与用户体验	35分	需求覆盖度、界面美观度、交互流畅性、响应式设计、数据展示效果
创新性与工程实践	25分	是否超出基础需求、架构设计、性能优化、代码复用性、工程化思维

6.3 完整裁判打分代码

创建文件 judge_scoring.py：

"""
Gemini 3.1 Pro 裁判打分系统
读取三个模型的HTML代码产出，从三个维度进行量化打分
"""

import os
import json
import time
import google.generativeai as genai

# ============ 配置区 ============
GEMINI_API_KEY = "your-gemini-api-key"
GEMINI_MODEL = "gemini-3.1-pro"  # 按实际模型标识调整

OUTPUT_DIR = "outputs"
REPORT_FILE = "report.json"
# ================================


def read_html_file(filepath: str) -> str:
    """读取HTML文件内容"""
    if not os.path.exists(filepath):
        raise FileNotFoundError(f"文件不存在: {filepath}")

    with open(filepath, "r", encoding="utf-8") as f:
        content = f.read()

    print(f"[INFO] 读取文件: {filepath}")
    print(f"  - 文件大小: {len(content)} 字符")
    return content


def build_judge_prompt(glm52_code: str, kimi27_code: str, opus48_code: str) -> str:
    """构建裁判模型评分提示词"""

    prompt = f"""你是一位资深的大模型评测专家和全栈工程师。请对以下三个AI模型生成的HTML代码进行严格评审。

## 测试任务背景
三个模型被要求开发一个"单文件HTML网页Excel数据分析与可视化工具"，具体要求包括：
- 上传.xlsx/.xls文件，SheetJS解析
- 多Sheet支持，搜索/分页/横向滚动
- 自动识别字段类型
- 统计行列数/缺失值/唯一值/最大最小平均求和
- 中文分析报告
- ECharts图表，用户自定义X/Y字段和图表类型

## 三个模型的代码产出

### 模型A：GLM-5.2
```html
{glm52_code[:30000]}

模型B：Kimi 2.7 Code

{kimi27_code[:30000]}

模型C：Opus 4.8

{opus48_code[:30000]}

评分要求

请按以下三个维度对每个模型分别打分（满分100分），并给出详细评审理由。

维度一：代码质量与可运行性（40分）

代码结构是否清晰，HTML/CSS/JS是否合理分离
注释是否完整，变量命名是否规范
代码是否可以直接在浏览器中打开运行
是否有错误处理机制（如文件格式校验、异常捕获）
外部依赖是否正确通过CDN引入

维度二：功能完整性与用户体验（35分）

是否覆盖了所有需求功能点
界面设计是否美观现代
用户交互是否流畅直观
是否支持响应式布局
数据展示和图表渲染效果

维度三：创新性与工程实践（25分）

是否超出基础需求，实现了额外功能
代码架构设计是否合理
是否有性能优化考虑
代码复用性和可维护性
是否体现了工程化思维

输出格式（严格JSON）

请直接输出以下JSON格式，不要包含任何其他文字：

{{
  "evaluation": {{
    "glm52": {{
      "model_name": "GLM-5.2",
      "scores": {{
        "code_quality": {{"score": 0, "max": 40, "comment": ""}},
        "functionality": {{"score": 0, "max": 35, "comment": ""}},
        "innovation": {{"score": 0, "max": 25, "comment": ""}}
      }},
      "total_score": 0,
      "overall_assessment": "",
      "strengths": [],
      "weaknesses": []
    }},
    "kimi27": {{
      "model_name": "Kimi 2.7 Code",
      "scores": {{
        "code_quality": {{"score": 0, "max": 40, "comment": ""}},
        "functionality": {{"score": 0, "max": 35, "comment": ""}},
        "innovation": {{"score": 0, "max": 25, "comment": ""}}
      }},
      "total_score": 0,
      "overall_assessment": "",
      "strengths": [],
      "weaknesses": []
    }},
    "opus48": {{
      "model_name": "Opus 4.8",
      "scores": {{
        "code_quality": {{"score": 0, "max": 40, "comment": ""}},
        "functionality": {{"score": 0, "max": 35, "comment": ""}},
        "innovation": {{"score": 0, "max": 25, "comment": ""}}
      }},
      "total_score": 0,
      "overall_assessment": "",
      "strengths": [],
      "weaknesses": []
    }}
  }},
  "ranking": [],
  "summary": ""
}}


请确保：
1. 每个维度的评分理由具体、有说服力
2. strengths和weaknesses各列出3-5条
3. ranking按总分从高到低排列
4. summary用中文总结本次评测的核心发现

"""

    return prompt


def call_gemini_judge(prompt: str, max_retries: int = 3) -> dict:
    """调用Gemini 3.1 Pro进行裁判打分"""
    genai.configure(api_key=GEMINI_API_KEY)
    model = genai.GenerativeModel(GEMINI_MODEL)

    print(f"[Gemini 3.1 Pro] 正在调用裁判模型...")
    print(f"  - 提示词长度: {len(prompt)} 字符")

    for attempt in range(1, max_retries + 1):
        try:
            response = model.generate_content(
                prompt,
                generation_config=genai.types.GenerationConfig(
                    temperature=0.1,       # 最低温度，确保评分一致性
                    max_output_tokens=8192,
                    top_p=0.95,
                ),
            )

            content = response.text
            print(f"[Gemini 3.1 Pro] 裁判打分完成 (第{attempt}次尝试)")
            print(f"  - 响应长度: {len(content)} 字符")

            # 提取JSON
            json_str = extract_json(content)
            result = json.loads(json_str)
            return result

        except json.JSONDecodeError as e:
            print(f"[Gemini 3.1 Pro] JSON解析失败 (第{attempt}次): {e}")
            if attempt < max_retries:
                time.sleep(2 ** attempt)
            else:
                raise
        except Exception as e:
            print(f"[Gemini 3.1 Pro] 第{attempt}次调用失败: {e}")
            if attempt < max_retries:
                time.sleep(2 ** attempt)
            else:
                raise RuntimeError(f"Gemini裁判模型调用失败，已重试{max_retries}次") from e


def extract_json(text: str) -> str:
    """从模型响应中提取JSON字符串"""
    # 尝试匹配 ```json ... ```代码块
    import re
    pattern = r'```json\s*\n(.*?)```'
    match = re.search(pattern, text, re.DOTALL)
    if match:
        return match.group(1).strip()

    # 尝试匹配 { ... } 最外层JSON
    pattern = r'\{[\s\S]*\}'
    match = re.search(pattern, text)
    if match:
        return match.group(0).strip()

    return text.strip()


def print_evaluation_report(report: dict):
    """打印格式化的评测报告"""
    evaluation = report["evaluation"]
    ranking = report["ranking"]

    print("\n" + "=" * 70)
    print("                    最终评测报告")
    print("=" * 70)

    for model_key in ranking:
        model_data = evaluation[model_key]
        scores = model_data["scores"]

        print(f"\n{'─' * 70}")
        print(f"  【{model_data['model_name']}】  总分: {model_data['total_score']}/100")
        print(f"{'─' * 70}")

        print(f"  代码质量与可运行性: {scores['code_quality']['score']}/{scores['code_quality']['max']}")
        print(f"    └ {scores['code_quality']['comment']}")

        print(f"  功能完整性与用户体验: {scores['functionality']['score']}/{scores['functionality']['max']}")
        print(f"    └ {scores['functionality']['comment']}")

        print(f"  创新性与工程实践: {scores['innovation']['score']}/{scores['innovation']['max']}")
        print(f"    └ {scores['innovation']['comment']}")

        print(f"\n  总体评价: {model_data['overall_assessment']}")
        print(f"  优势: {'; '.join(model_data['strengths'])}")
        print(f"  不足: {'; '.join(model_data['weaknesses'])}")

    print(f"\n{'─' * 70}")
    print(f"  排名: {' > '.join([evaluation[m]['model_name'] for m in ranking])}")
    print(f"{'─' * 70}")

    print(f"\n  评测总结: {report['summary']}")
    print("=" * 70)


def main():
    """主流程"""
    print("=" * 70)
    print("Gemini 3.1 Pro 裁判模型打分系统")
    print("=" * 70)

    # 1. 读取三个模型的代码产出
    glm52_code = read_html_file(os.path.join(OUTPUT_DIR, "glm52_result.html"))
    kimi27_code = read_html_file(os.path.join(OUTPUT_DIR, "kimi27_result.html"))
    opus48_code = read_html_file(os.path.join(OUTPUT_DIR, "opus48_result.html"))

    # 2. 构建裁判评分提示词
    judge_prompt = build_judge_prompt(glm52_code, kimi27_code, opus48_code)

    # 3. 调用裁判模型打分
    report = call_gemini_judge(judge_prompt)

    # 4. 保存评测报告
    os.makedirs(OUTPUT_DIR, exist_ok=True)
    report_path = os.path.join(OUTPUT_DIR, REPORT_FILE)
    with open(report_path, "w", encoding="utf-8") as f:
        json.dump(report, f, ensure_ascii=False, indent=2)
    print(f"\n[SUCCESS] 评测报告已保存至: {report_path}")

    # 5. 打印格式化报告
    print_evaluation_report(report)


if __name__ == "__main__":
    main()

6.4 裁判系统的设计考量

截断策略：每个模型的HTML代码限制在30000字符，避免超出Gemini的上下文限制（虽然Gemini支持百万级上下文，但保持合理长度能提高评分质量）
温度设为0.1：裁判评分需要极高的稳定性，同一批代码多次评分应得到一致结果
结构化输出：通过JSON Schema约束，确保评分结果可解析、可对比
维度平衡：代码质量占40%（基础），功能完整性占35%（核心），创新性占25%（加分项）

七、结果汇总与分析

7.1 评测结果示例

以下为一次典型评测的输出结果（实际数值会因模型版本和API调用而异）：

======================================================================
                    最终评测报告
======================================================================

──────────────────────────────────────────────────────────────────────
  【Opus 4.8】  总分: 88/100
──────────────────────────────────────────────────────────────────────
  代码质量与可运行性: 36/40
    └ 代码结构清晰，HTML/CSS/JS分层合理，CDN引入正确，可直接运行
  功能完整性与用户体验: 31/35
    └ 所有核心功能均已实现，界面采用现代设计风格，ECharts图表交互流畅
  创新性与工程实践: 21/25
    └ 额外实现了数据导出功能，采用事件驱动架构，代码模块化程度高

  总体评价: Opus 4.8在本次评测中表现最为出色，代码质量高，功能实现完整
  优势: 代码结构优雅; 图表交互体验好; 错误处理完善; 响应式设计到位
  不足: 部分注释为英文; 搜索功能可优化为大写不敏感

──────────────────────────────────────────────────────────────────────
  【Kimi 2.7 Code】  总分: 82/100
──────────────────────────────────────────────────────────────────────
  代码质量与可运行性: 33/40
    └ 代码可正常运行，CDN依赖正确，但部分CSS内联过长影响可读性
  功能完整性与用户体验: 29/35
    └ 功能覆盖度高，界面简洁大方，中文分析报告内容详实
  创新性与工程实践: 20/25
    └ 增加了数据导出CSV功能，分页组件设计良好，但代码复用性可提升

  总体评价: Kimi 2.7 Code在前端开发任务上表现优秀，中文报告质量突出
  优势: 中文报告质量高; 界面设计符合国内审美; 功能实现完整
  不足: CSS组织可优化; 缺少数据缓存机制

──────────────────────────────────────────────────────────────────────
  【GLM-5.2】  总分: 78/100
──────────────────────────────────────────────────────────────────────
  代码质量与可运行性: 32/40
    └ 代码结构合理，注释完整，但部分边界情况处理不够完善
  功能完整性与用户体验: 27/35
    └ 核心功能已实现，但图表类型切换交互略显生硬
  创新性与工程实践: 19/25
    └ 实现了基础需求，但缺少额外功能亮点，代码可进一步模块化

  总体评价: GLM-5.2完成了基本功能需求，代码质量稳定，但缺少亮点
  优势: 代码稳定可靠; 注释详细; 错误处理基本到位
  不足: 缺少创新功能; 交互体验可优化; 图表配置界面略显简陋

──────────────────────────────────────────────────────────────────────
  排名: Opus 4.8 > Kimi 2.7 Code > GLM-5.2
──────────────────────────────────────────────────────────────────────

  评测总结: 在本轮编程任务评测中，三个模型均成功完成了基础需求。
  Opus 4.8在代码工程化和创新性上领先，Kimi 2.7 Code在中文内容和
  前端交互上表现突出，GLM-5.2稳定可靠但缺乏亮点。建议根据实际
  业务场景选择模型：追求代码质量选Opus，注重中文体验选Kimi，
  需要稳定输出选GLM。
======================================================================

7.2 关键经验总结

从本次评测中，我们总结出几条关键经验：

大模型评测不能只看跑分：MMLU、HumanEval等基准测试的分数与实际工程任务的完成质量存在差异，实际场景测试更有参考价值
代码生成任务需要低温度：0.2-0.3的温度区间能获得最稳定的代码输出
裁判模型的选择至关重要：中立、长上下文、结构化输出是裁判模型的三个必要条件
统一接入降低评测成本：在微元算力(weytoken) 等平台上，评测三个模型只需修改 model 参数，无需切换三套SDK

八、构建自动化评测流水线

8.1 一键运行脚本

将上述所有步骤整合为一个自动化流水线，创建 pipeline.py：

"""
自动化大模型评测流水线
一键运行：生成代码 → 裁判打分 → 生成报告
"""

import os
import sys
import json
import time
import subprocess
from datetime import datetime


def run_step(name: str, script: str) -> bool:
    """运行单个评测步骤"""
    print(f"\n{'#' * 60}")
    print(f"# 步骤: {name}")
    print(f"{'#' * 60}")

    start_time = time.time()
    result = subprocess.run(
        [sys.executable, script],
        capture_output=False,
        text=True,
    )
    elapsed = time.time() - start_time

    if result.returncode == 0:
        print(f"\n[OK] {name} 完成，耗时 {elapsed:.1f}秒")
        return True
    else:
        print(f"\n[FAIL] {name} 失败，返回码: {result.returncode}")
        return False


def generate_markdown_report(report_file: str, output_file: str):
    """将JSON报告转换为Markdown格式"""
    with open(report_file, "r", encoding="utf-8") as f:
        report = json.load(f)

    evaluation = report["evaluation"]
    ranking = report["ranking"]

    md = []
    md.append("# 大模型科学评测报告")
    md.append(f"\n> 自动生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    md.append(f"\n> 评测任务: 单文件HTML网页Excel数据分析与可视化工具")
    md.append(f"\n> 裁判模型: Gemini 3.1 Pro")
    md.append("\n---\n")

    # 排名总览
    md.append("## 排名总览\n")
    md.append("| 排名 | 模型 | 代码质量(40) | 功能完整性(35) | 创新性(25) | 总分 |")
    md.append("|------|------|-------------|---------------|-----------|------|")
    for rank, model_key in enumerate(ranking, 1):
        model = evaluation[model_key]
        s = model["scores"]
        md.append(
            f"| {rank} | {model['model_name']} | "
            f"{s['code_quality']['score']} | {s['functionality']['score']} | "
            f"{s['innovation']['score']} | **{model['total_score']}** |"
        )

    md.append("\n---\n")

    # 各模型详细分析
    for model_key in ranking:
        model = evaluation[model_key]
        s = model["scores"]

        md.append(f"## {model['model_name']} (总分: {model['total_score']}/100)\n")
        md.append(f"**总体评价**: {model['overall_assessment']}\n")

        md.append("### 分维度评分\n")
        md.append(f"- **代码质量与可运行性** ({s['code_quality']['score']}/{s['code_quality']['max']}): {s['code_quality']['comment']}")
        md.append(f"- **功能完整性与用户体验** ({s['functionality']['score']}/{s['functionality']['max']}): {s['functionality']['comment']}")
        md.append(f"- **创新性与工程实践** ({s['innovation']['score']}/{s['innovation']['max']}): {s['innovation']['comment']}")

        md.append(f"\n**优势**:")
        for strength in model["strengths"]:
            md.append(f"- {strength}")

        md.append(f"\n**不足**:")
        for weakness in model["weaknesses"]:
            md.append(f"- {weakness}")

        md.append("\n---\n")

    md.append(f"## 总结\n")
    md.append(report["summary"])

    with open(output_file, "w", encoding="utf-8") as f:
        f.write("\n".join(md))

    print(f"[SUCCESS] Markdown报告已生成: {output_file}")


def main():
    """主流水线"""
    print("=" * 60)
    print("  自动化大模型评测流水线")
    print(f"  启动时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print("=" * 60)

    steps = [
        ("GLM-5.2 代码生成", "glm52_generate.py"),
        ("Kimi 2.7 Code 代码生成", "kimi27_generate.py"),
        ("Opus 4.8 代码生成", "opus48_generate_anthropic.py"),
        ("Gemini 3.1 Pro 裁判打分", "judge_scoring.py"),
    ]

    results = {}
    for name, script in steps:
        success = run_step(name, script)
        results[name] = success
        if not success:
            print(f"\n[ERROR] {name} 失败，流水线终止")
            sys.exit(1)

    # 生成Markdown报告
    print(f"\n{'#' * 60}")
    print(f"# 步骤: 生成最终报告")
    print(f"{'#' * 60}")

    generate_markdown_report(
        report_file=os.path.join("outputs", "report.json"),
        output_file=os.path.join("outputs", "evaluation_report.md"),
    )

    print("\n" + "=" * 60)
    print("  评测流水线运行完成！")
    print(f"  结束时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print("=" * 60)

    print("\n生成的文件:")
    print("  outputs/glm52_result.html      - GLM-5.2 代码产出")
    print("  outputs/kimi27_result.html     - Kimi 2.7 Code 代码产出")
    print("  outputs/opus48_result.html     - Opus 4.8 代码产出")
    print("  outputs/report.json             - 原始评测报告(JSON)")
    print("  outputs/evaluation_report.md    - 最终评测报告(Markdown)")


if __name__ == "__main__":
    main()

8.2 运行流水线

# 确保所有API Key已设置
export WEYTOKEN_API_KEY="your-weytoken-key"
export ANTHROPIC_API_KEY="your-anthropic-key"
export GEMINI_API_KEY="your-gemini-key"

# 一键运行完整评测
python pipeline.py

九、总结

9.1 核心收获

通过本次实战教程，你完成了以下关键实践：

科学评测方法论：掌握了"同任务+多模型+独立裁判"的三段式评测范式
多模型API调用：熟练使用 OpenAI SDK、Anthropic SDK、Google Generative AI SDK 调用不同厂商的大模型
提示词工程：学会了如何设计一个能有效区分模型能力的测试任务提示词
裁判模型系统：构建了基于 Gemini 3.1 Pro 的自动化打分系统
自动化流水线：将评测流程整合为可复用的自动化脚本

9.2 评测不是终点

需要强调的是，一次评测的结果不代表模型的全部能力。不同模型在不同任务上各有优势：

Opus 4.8：在复杂工程任务和代码质量上表现领先
Kimi 2.7 Code：在前端开发和中文内容生成上有独特优势
GLM-5.2：国产模型中的佼佼者，稳定可靠

建议根据你的实际业务场景，设计个性化的评测任务，选择最适合的模型。

9.3 关于统一API接入

在多模型评测过程中，对接不同厂商的API是最耗时的工作之一。对于企业级应用场景，我们建议使用 微元算力(weytoken) 这样的大模型API聚合平台，通过统一的 OpenAI 兼容接口接入数十种主流大模型，同时满足数据安全、审计合规、成本管控等企业级需求。

9.4 下一步

尝试设计自己的评测任务（如API开发、数据分析、UI设计等）
扩展评测维度，加入性能指标（响应时间、Token消耗等）
使用更多模型进行横向对比（如 DeepSeek、Qwen、Llama 等）
将评测流程集成到CI/CD中，实现模型能力的持续监控

完整代码仓库

本文所有代码已整理为独立可运行的脚本，文件结构如下：

evaluation/
├── task_prompt.txt                    # 统一测试任务提示词
├── glm52_generate.py                  # GLM-5.2 调用脚本
├── kimi27_generate.py                 # Kimi 2.7 Code 调用脚本
├── opus48_generate_anthropic.py       # Opus 4.8 调用脚本 (Anthropic SDK)
├── judge_scoring.py                   # Gemini 3.1 Pro 裁判打分脚本
├── pipeline.py                        # 自动化评测流水线
└── outputs/
    ├── glm52_result.html
    ├── kimi27_result.html
    ├── opus48_result.html
    ├── report.json
    └── evaluation_report.md

数据来源声明

本文涉及的模型评测数据、代码示例和评分结果均基于以下公开可获取的信息和工具：

模型API：GLM-5.2（智谱AI）、Kimi 2.7 Code（Moonshot AI）、Opus 4.8（Anthropic）、Gemini 3.1 Pro（Google）
评测方法：作者独立设计的科学评测方案，遵循"同任务+多模型+独立裁判"的方法论
代码工具：所有Python脚本均为原创，使用官方SDK和公开API接口
API聚合平台：微元算力(weytoken) 提供统一的企业级大模型API接入服务
免责声明：评测结果受模型版本、API参数、网络环境等因素影响，仅供参考。实际使用前请自行验证。本文不构成任何投资建议或产品推荐。

如果你觉得这篇文章对你有帮助，欢迎点赞、收藏、转发。有任何问题欢迎在评论区留言交流。

DeepSeek技术社区

欢迎加入DeepSeek 技术社区。在这里，你可以找到志同道合的朋友，共同探索AI技术的奥秘。

更多推荐

只要13个单词，就能给ChatGPT“下毒”？「美版贴吧」Reddit，正沦为AI“投毒基地”

DeepSeek技术社区

通用大模型崛起，企业自研模型还有必要吗？

DeepSeek技术社区

实测 Grok4.3 vs Claude Opus vs GPT 系列：长文档合同分析能力横向对比

摘要：针对企业法务、商务等场景的超长合同分析需求，实测对比Grok4.3、ClaudeOpus和GPT-4o三款主流大模型的表现。ClaudeOpus以92分领先，长文本记忆和风险识别能力突出，适合高风险合同；GPT-4o法律推理强，但超10万字文档易丢失细节；Grok4.3虽支持百万Token加载，但法律专业性和幻觉控制薄弱，仅适合低风险速读。测试基于标准化数据集，覆盖要素提取、风险识别、逻辑

DeepSeek技术社区

所有评论(0)

查看更多评论

m0_37841076

@m0_37841076

已为社区贡献4条内容

三模型同台竞技实战教程：GLM-5.2 vs Kimi 2.7 Code vs Opus 4.8，用 Gemini 3.1 Pro 做裁判，手把手教你科学评测大模型真实能力 - 微元算力(weytok

m0_37841076

摘要

目录

一、教程目标与环境准备

1.1 我们要做什么

1.2 环境准备

1.3 项目结构

二、设计Agent测试任务（提示词工程）

2.1 任务设计原则

2.2 完整提示词

三、调用GLM-5.2（含完整代码）

3.1 GLM-5.2 简介

3.2 完整调用代码

3.3 运行说明

3.4 关键设计说明

四、调用Kimi 2.7 Code（含完整代码）

4.1 Kimi 2.7 Code 简介

4.2 完整调用代码

4.3 与GLM-5.2调用的差异

五、调用Opus 4.8（含完整代码）

5.1 Opus 4.8 简介

5.2 完整调用代码（方式一：Anthropic SDK）

5.3 完整调用代码（方式二：OpenAI兼容接口）

六、裁判模型打分系统（Gemini-3.1-Pro裁判，含完整代码）

6.1 裁判模型的选择

6.2 三个打分维度

6.3 完整裁判打分代码

模型B：Kimi 2.7 Code

模型C：Opus 4.8

评分要求

维度一：代码质量与可运行性（40分）

维度二：功能完整性与用户体验（35分）

维度三：创新性与工程实践（25分）

输出格式（严格JSON）

6.4 裁判系统的设计考量

七、结果汇总与分析

7.1 评测结果示例

7.2 关键经验总结

八、构建自动化评测流水线

8.1 一键运行脚本

8.2 运行流水线

九、总结

9.1 核心收获

9.2 评测不是终点

9.3 关于统一API接入

9.4 下一步

完整代码仓库

数据来源声明

所有评论(0)

温馨提示：您尚未绑定手机号

m0_37841076