基于 Phoenix 构建 AI/LLM 应用评估器：从错误分析到 CI 门禁的完整实战指南

• 可观测性
• AI 评测
• LLMOps
• AI 应用
• 人工智能

【免费下载链接】phoenix

AI Observability & Evaluation

项目地址：https://gitcode.com/gh_mirrors/phoenix13/phoenix

点击查看免费下载

Phoenix 的 evals 技能文档（.agents/skills/phoenix-evals/SKILL.md）系统阐述了在 AI/LLM 应用上构建评估器（Evaluator）的完整方法论与工程实践。本文以该文档为核心骨架，结合仓库源码（packages/phoenix-evals、packages/phoenix-client）验证其底层实现，整理出一套"代码优先、LLM 处理细节、人类提供真值"的评估体系：你将掌握三种评估器类型的取舍、代码与 LLM 评估器的编写方式、DataFrame 批量评估、实验运行与验证校准，以及如何将评估接入 pytest / Vitest / Jest 作为 CI 门禁。

评估方法论：三种评估器与选择决策

Phoenix 将评估器划分为三种类型，它们在速度、成本与适用场景上形成互补：

类型	速度	成本	适用场景
代码评估器（Code）	快	低	正则、JSON、格式、精确匹配等确定性校验
LLM 评估器（LLM）	中	中	主观质量、复杂标准（如是否有帮助、是否忠实）
人工评估（Human）	慢	高	真值（Ground Truth）、校准参考

决策顺序：先代码（Code）→ 仅当代码无法表达标准时用 LLM → 用人工进行校准。这一"代码优先"原则贯穿整个技能文档的 Key Principles（见.agents/skills/phoenix-evals/SKILL.md），其核心思想是：凡是能用确定性逻辑表达的标准，就不要引入 LLM 的随机性与成本。

评估结果的结构化约定

无论哪种类型的评估器，返回结果都遵循统一的结构：

属性	是否必需	说明
name	是	评估器名称
kind	是	"code"、"llm"、"human"
score	否*	0-1 数值
label	否*	"pass"/"fail"（或其他二分类标签）
explanation	否	判断依据/理由

*score与label至少提供一个。

在源码中，这一约定由 Score 数据类 实现，批量评估时每个结果会序列化为包含name、score、label、explanation、metadata、kind、direction等字段的字典。

Binary > Likert：用二元判断代替 1-5 量表

技能文档强调：优先使用 pass/fail 二元判断，而不是 1-5 分制量表。二元标准的界定更清晰、更易校准。实践中应将一个复杂的 Likert 问题拆解为多个独立的二元检查：

# 多个二元检查代替一个 Likert 量表 evaluators = [ AnswersQuestion(), # Yes/No UsesContext(), # Yes/No NoHallucination(), # Yes/No ]

构建评估器的前置条件与生命周期

在动手写代码之前，先回答三个问题（参考 evaluators-overview）：

1. 标准明确（Clear criteria）——具体可判，而不是"回答得好不好"；
2. 带人工标注的测试集（Labeled test set）——100+ 条带人类标注的样本；
3. 可测量的准确率（Measured accuracy）——部署前必须知道 TPR/TNR。

评估器的完整生命周期为：Discover（错误分析发现模式）→ Design（定义标准与测试用例）→ Implement（构建代码或 LLM 评估器）→ Calibrate（对照人工标签验证）→ Deploy（接入实验/CI 流水线）→ Monitor（持续跟踪准确率）→ Maintain（随产品演进更新）。

什么不该自动化

• 罕见问题：样本少于 5 例？先放入观察清单，不值得构建评估器；
• 快速修复：改个 prompt 就能解决的，先改 prompt；
• 标准仍在演进：先稳定定义，再考虑自动化。

环境准备：Python 与 TypeScript 双栈安装

评估器技能支持 Python 与 TypeScript 两种语言（详见 setup-python 与 setup-typescript）。

Python 安装

# 核心 Phoenix 包（包含 client、evals、otel） pip install arize-phoenix # 或者按需安装独立包 pip install arize-phoenix-client # 仅 Phoenix 客户端 pip install arize-phoenix-evals # 评估工具 pip install arize-phoenix-otel # OpenTelemetry 集成

LLM-as-judge 评估器还需要对应提供商的 SDK：

pip install openai # OpenAI pip install anthropic # Anthropic pip install google-genai # Google

可选：验证准确率时需要 scikit-learn 来计算 TPR/TNR：

pip install scikit-learn

验证安装

from phoenix.client import Client from phoenix.evals import LLM, ClassificationEvaluator from phoenix.otel import register # 所有导入都应成功 print("Phoenix Python setup complete")

Evals 2.0 核心导入

技能文档强调使用 2.0 新一代 API，并明确不要使用1.0 遗留导入（OpenAIModel、AnthropicModel、run_evals、llm_classify）：

from phoenix.client import Client from phoenix.evals import ( ClassificationEvaluator, # LLM 分类评估器（推荐） LLM, # 供应商无关的 LLM 封装 async_evaluate_dataframe, # 批量评估 DataFrame（推荐，异步） evaluate_dataframe, # 批量评估 DataFrame（同步） create_evaluator, # 代码评估器装饰器 create_classifier, # LLM 分类评估器工厂 bind_evaluator, # 列名到评估器参数的映射 Score, # Score 数据类 ) from phoenix.evals.utils import to_annotation_dataframe # 将结果格式化为 Phoenix 标注

API 偏好建议：ClassificationEvaluator优于create_classifier（参数更多、可定制性更强）；async_evaluate_dataframe优于evaluate_dataframe（LLM 评估吞吐更高）。这些 API 在源码 evaluators.py 中均有对应实现（create_evaluator、create_classifier、bind_evaluator、async_evaluate_dataframe分别位于 L828、L1133、L1222、L1559）。

构建代码评估器：确定性优先

代码评估器（Code Evaluator）不调用 LLM，速度快、成本低、结果可复现（详见 evaluators-code-python）。

基本模式：@create_evaluator装饰器

import re import json from phoenix.evals import create_evaluator @create_evaluator(name="has_citation", kind="code") def has_citation(output: str) -> bool: return bool(re.search(r'\[\d+\]', output)) @create_evaluator(name="json_valid", kind="code") def json_valid(output: str) -> bool: try: json.loads(output) return True except json.JSONDecodeError: return False

参数绑定：评估器可访问的字段

参数	说明
output	任务输出
input	示例输入
expected	期望输出
metadata	示例元数据

@create_evaluator(name="matches_expected", kind="code") def matches_expected(output: str, expected: dict) -> bool: return output.strip() == expected.get("answer", "").strip()

常见确定性模式

• 正则匹配：re.search(pattern, output)
• JSON schema 校验：jsonschema.validate()
• 关键词检查：keyword in output.lower()
• 长度检查：len(output.split())
• 相似度：editdistance.eval()或 Jaccard 系数

返回值类型约定

@create_evaluator装饰的函数返回值会被自动转换为标准评估结果：

返回类型	结果
bool	True→ score=1.0, label="True"；False→ score=0.0, label="False"
float/int	直接作为score值
str（短，≤3 个词）	作为label值
str（长，≥4 个词）	作为explanation值
含score/label/explanation的dict	直接映射到 Score 字段
Score对象	原样使用

重要：Code 与 LLM 评估器的区别

@create_evaluator装饰器只是包装一个普通 Python 函数：

• kind="code"（默认）：用于不调用 LLM的确定性评估器；
• kind="llm"：标记为基于 LLM 的评估器，但LLM 调用需要你自己在函数内部实现，装饰器不会替你调用 LLM。

因此，大多数基于 LLM 的评估请优先使用ClassificationEvaluator——它会自动处理 LLM 调用、结构化输出解析与解释生成。

预置代码评估器

phoenix.evals.metrics模块内置了MatchesRegex等代码评估器：

from phoenix.client.experiments import create_evaluator from phoenix.evals.metrics import MatchesRegex date_format = MatchesRegex(pattern=r"\d{4}-\d{2}-\d{2}")

构建 LLM 评估器：处理主观标准

当标准是主观的、代码无法表达时，使用 LLM 评估器（详见 evaluators-llm-python）。其核心组件是ClassificationEvaluator+LLM封装（源码见 wrapper.py 与 evaluators.py）。

快速上手

from phoenix.evals import ClassificationEvaluator, LLM llm = LLM(provider="openai", model="gpt-4o") HELPFULNESS_TEMPLATE = """Rate how helpful the response is. <question>{{input}}</question> <response>{{output}}</response> "helpful" means directly addresses the question. "not_helpful" means does not address the question. Your answer (helpful/not_helpful):""" helpfulness = ClassificationEvaluator( name="helpfulness", prompt_template=HELPFULNESS_TEMPLATE, llm=llm, choices={"not_helpful": 0, "helpful": 1} )

模板变量与 XML 标签约定

用 XML 标签包裹变量，让 LLM 清晰区分不同字段：

变量	XML 标签
{{input}}	<question>{{input}}</question>
{{output}}	<response>{{output}}</response>
{{reference}}	<reference>{{reference}}</reference>
{{context}}	<context>{{context}}</context>

create_classifier工厂

create_classifier是返回ClassificationEvaluator的简写工厂。直接实例化ClassificationEvaluator可获得更多参数与定制能力：

from phoenix.evals import create_classifier, LLM relevance = create_classifier( name="relevance", prompt_template="""Is this response relevant to the question? <question>{{input}}</question> <response>{{output}}</response> Answer (relevant/irrelevant):""", llm=LLM(provider="openai", model="gpt-4o"), choices={"relevant": 1.0, "irrelevant": 0.0}, )

输入列名映射

数据框列名必须与模板变量一致。不一致时有两种处理方式：

# 方案 1：重命名列以匹配模板变量 df = df.rename(columns={"user_query": "input", "ai_response": "output"}) # 方案 2：使用 bind_evaluator from phoenix.evals import bind_evaluator bound = bind_evaluator( evaluator=helpfulness, input_mapping={"input": "user_query", "output": "ai_response"}, )

Prompt 编写最佳实践

1. 具体化——明确定义 pass/fail 的含义；
2. 包含示例——为每个标签展示具体案例；
3. 默认生成解释——ClassificationEvaluator自动附带explanation；
4. 研究内置 prompt——参考 classification_evaluator_configs 中 Faithfulness、Correctness、RetrievalRelevance 等结构化良好的评估 prompt（仓库中对应的 YAML 配置位于 prompts/classification_evaluator_configs）。

预置评估器：拿来即用与使用注意

phoenix.evals.metrics（Python）与@arizeai/phoenix-evals（TypeScript）提供了一系列开箱即用的 LLM 评估器。命名约定为 Python 用<Name>Evaluator，TypeScript 用create<Name>Evaluator。技能文档明确提示：预置评估器仅用于探索，生产环境前必须验证。

预置评估器一览

评估器	输入字段（Python 名）	标签（1.0 / 0.0）	方向
Conciseness	input,output	concise/verbose	maximize
Correctness	input,output	correct/incorrect	maximize
Faithfulness	input,output,context	faithful/unfaithful	maximize
Hallucination	input,output	hallucinated/grounded	minimize
PiiDetection	conversation	pii_detected/no_pii_detected	minimize
Refusal	input,output	refused/answered	neutral
RetrievalRelevance	input,context	relevant/irrelevant	maximize
ToolInvocation	input,available_tools,tool_selection	correct/incorrect	maximize
ToolResponseHandling	input,tool_call,tool_result,output	correct/incorrect	maximize
ToolSelection	input,available_tools,tool_selection	correct/incorrect	maximize
Toxicity	text	toxic/non-toxic	minimize
UserFriction	conversation,user_message	friction/no_friction	minimize

其中minimize方向的评估器，高分代表坏结果。这些类在源码 metrics 目录中均有实现（如ConcisenessEvaluator、CorrectnessEvaluator、FaithfulnessEvaluator、DocumentRelevanceEvaluator等，均为ClassificationEvaluator的子类）。

使用示例

from phoenix.evals import LLM from phoenix.evals.metrics import FaithfulnessEvaluator llm = LLM(provider="openai", model="gpt-4o") faithfulness_eval = FaithfulnessEvaluator(llm=llm)

import { createFaithfulnessEvaluator } from "@arizeai/phoenix-evals"; import { openai } from "@ai-sdk/openai"; const faithfulnessEval = createFaithfulnessEvaluator({ model: openai("gpt-4o") });

关键评估器的语义辨析

Faithfulness vs. Hallucination：两者都检查回答是否有事实依据支撑，区别在于"依据来源"不同。Faithfulness 对照单独提供的context（检索文档——用于 RAG 场景）；Hallucination 对照对话本身：input存放助手所见到的完整历史（包括工具调用与结果），没有context字段——用于多轮 Agent 与聊天场景。

PII 检测需覆盖完整记录：唯一的conversation字段应包含全部内容——系统指令、工具调用与结果、检索文档——而不仅是用户看到的部分。评估器的explanation是结构化的FINDINGS:块（或FINDINGS: none），可解析出逐条的分类。占位符与脱敏内容（[REDACTED]、555-01xx号码、example.com地址等样例标记）会被刻意忽略，所以不要用假的标识符构造测试用例。

RetrievalRelevance 的字段约定

RetrievalRelevanceEvaluator与来源无关，对检索信息整体打分：只要任一有意义的部分实质性帮助了请求，该步骤即为relevant。标签为relevant/irrelevant，方向为 maximize（relevant=1.0，irrelevant=0.0），每个结果附带 judge 的explanation。

两个字段约定容易出错且会悄悄改变测量对象：

• input应该是用户的请求（如 trace 根的input.value），而不是改写后的工具参数或生成的 SQL 查询；
• context应包含你想评判的检索范围：单文档评估传一个文档，整体步骤评估将所有返回项拼接成一个context。

Relevance 不是 Correctness：过时或被后续反驳的信息只要确实与主题相关，仍得relevant；检索失败（报错、超时、"无结果"）得irrelevant。

from phoenix.evals import LLM from phoenix.evals.metrics import RetrievalRelevanceEvaluator relevance_eval = RetrievalRelevanceEvaluator(llm=LLM(provider="openai", model="gpt-4o-mini")) scores = relevance_eval.evaluate({ "input": "What is the capital of France?", "context": "Paris is the capital and largest city of France.", }) print(scores[0].label) # "relevant"

RetrievalRelevanceEvaluator接受llm外加任意**kwargs透传给 LLM 客户端（如temperature=0.0），并要求模型支持工具调用或结构化输出。TypeScript 工厂在常规分类评估器参数之上，还支持可选的name、choices、promptTemplate、optimizationDirection覆盖。

何时使用预置评估器

场景	建议
探索	用它找需要 review 的 trace
找离群值	按分数排序
生产	先验证（>80% 人工一致性）
领域特定	构建自定义评估器

探索模式：批量打分并筛选

from phoenix.evals import evaluate_dataframe results_df = evaluate_dataframe(dataframe=traces, evaluators=[faithfulness_eval]) # Score 列是 dict —— 提取数值分数 scores = results_df["faithfulness_score"].apply( lambda x: x.get("score", 0.0) if isinstance(x, dict) else 0.0 ) low_scores = results_df[scores < 0.5] # Review these high_scores = results_df[scores > 0.9] # Also sample

批量评估 DataFrame：核心 2.0 API

evaluate_dataframe/async_evaluate_dataframe是 Evals 2.0 的批量评估核心 API（详见 evaluate-dataframe-python）。

推荐：异步版本

批量评估（尤其涉及 LLM 评估器）时优先使用异步版本以获得更高吞吐：

from phoenix.evals import async_evaluate_dataframe results_df = await async_evaluate_dataframe( dataframe=df, # pandas DataFrame，列名与评估器参数匹配 evaluators=[eval1, eval2], # 评估器列表 concurrency=5, # 最大并发 LLM 调用数（默认 3） exit_on_error=False, # 可选：出错即停（默认 True） max_retries=3, # 可选：重试失败/超时的 LLM 调用（默认 10） )

同步版本

from phoenix.evals import evaluate_dataframe results_df = evaluate_dataframe( dataframe=df, # pandas DataFrame，列名与评估器参数匹配 evaluators=[eval1, eval2], # 评估器列表 exit_on_error=False, # 可选：出错即停（默认 True） max_retries=3, # 可选：重试失败/超时的 LLM 调用（默认 10） )

结果列格式：字典而非数值

evaluate_dataframe返回输入 DataFrame 的副本并追加新列。结果列包含的是字典，不是原始数值。每个名为"foo"的评估器会新增两列：

列	类型	内容
foo_score	dict	{"name": "foo", "score": 1.0, "label": "True", "explanation": "...", "metadata": {...}, "kind": "code", "direction": "maximize"}
foo_execution_details	dict	{"status": "success", "exceptions": [], "execution_seconds": 0.001}

只有非 None 字段才会出现在 score 字典中。

提取数值分数

# 错误写法 —— 会失败或产生意外结果 score = results_df["relevance"].mean() # KeyError! score = results_df["relevance_score"].mean() # 尝试对字典求平均！ # 正确写法 —— 从字典中提取数值 scores = results_df["relevance_score"].apply( lambda x: x.get("score", 0.0) if isinstance(x, dict) else 0.0 ) mean_score = scores.mean()

提取标签与解释

labels = results_df["relevance_score"].apply( lambda x: x.get("label", "") if isinstance(x, dict) else "" ) explanations = results_df["relevance_score"].apply( lambda x: x.get("explanation", "") if isinstance(x, dict) else "" )

查找失败样本

scores = results_df["relevance_score"].apply( lambda x: x.get("score", 0.0) if isinstance(x, dict) else 0.0 ) failed_mask = scores < 0.5 failures = results_df[failed_mask]

输入列映射

评估器将每一行作为 dict 接收，列名必须与评估器期望的参数名一致。不一致时使用.bind()方法或bind_evaluator函数：

from phoenix.evals import bind_evaluator, create_evaluator, async_evaluate_dataframe @create_evaluator(name="check", kind="code") def check(response: str) -> bool: return len(response.strip()) > 0 # 方案 1：使用评估器的 .bind() 方法 check.bind(input_mapping={"response": "answer"}) results_df = await async_evaluate_dataframe(dataframe=df, evaluators=[check]) # 方案 2：使用 bind_evaluator 函数 bound = bind_evaluator(evaluator=check, input_mapping={"response": "answer"}) results_df = await async_evaluate_dataframe(dataframe=df, evaluators=[bound])

也可以直接重命名列名以匹配：

df = df.rename(columns={ "attributes.input.value": "input", "attributes.output.value": "output", })

不要使用遗留的 run_evals

# 错误 —— 1.0 遗留 API from phoenix.evals import run_evals results = run_evals(dataframe=df, evaluators=[eval1]) # 返回 List[DataFrame] —— 每个评估器一个 # 正确 —— 当前 2.0 API from phoenix.evals import async_evaluate_dataframe results_df = await async_evaluate_dataframe(dataframe=df, evaluators=[eval1]) # 返回单个 DataFrame，带 {name}_score 字典列

关键区别：run_evals返回每个评估器一个 DataFrame 的列表；async_evaluate_dataframe返回合并了所有结果的单个 DataFrame，使用{name}_score字典列格式，并通过bind_evaluator做输入映射（而非input_mapping=参数）。

运行实验：数据集、任务与评估的编排

run_experiment将数据集、任务函数与评估器编排为一次可追踪的实验（详见 experiments-running-python，API 实现见 packages/phoenix-client/src/phoenix/client/experiments）。

基本用法

from phoenix.client import Client from phoenix.client.experiments import run_experiment client = Client() dataset = client.datasets.get_dataset(name="qa-test-v1") def my_task(example): return call_llm(example.input["question"]) def exact_match(output, expected): return 1.0 if output.strip().lower() == expected["answer"].strip().lower() else 0.0 experiment = run_experiment( dataset=dataset, task=my_task, evaluators=[exact_match], experiment_name="qa-experiment-v1", )

任务函数

# 基本任务 def task(example): return call_llm(example.input["question"]) # 带上下文（RAG） def rag_task(example): return call_llm(f"Context: {example.input['context']}\nQ: {example.input['question']}")

评估器参数访问

参数	访问方式
output	任务输出
expected	示例的期望输出
input	示例输入
metadata	示例元数据

常用选项

experiment = run_experiment( dataset=dataset, task=my_task, evaluators=evaluators, experiment_name="my-experiment", dry_run=3, # 先用 3 个示例试运行 repetitions=3, # 每个示例运行 3 次 )

查看结果

print(experiment.aggregate_scores) # {'accuracy': 0.85, 'faithfulness': 0.92} for run in experiment.runs: print(run.output, run.scores)

稳定性与重复运行（repetitions）

当任务或评估器任一具有非确定性（LLM 调用、工具使用、流式输出、LLM-as-judge）时，单次运行的分数会有噪声。在小数据集上，单次运行的噪声可能淹没一次 prompt 变更带来的真实信号。对多次重复取平均，能让报告的分数反映 prompt 本身而非采样噪声：

run_experiment( # ... repetitions=3, )

何时使用 repetitions 的考量：

• 任务或评估器是 LLM 调用且数据集较小时，优先使用 repetitions；
• 单样本成本低、主要目的是"定分数"时优先 repetitions；需要覆盖更多行为时优先扩充数据集；
• 任务与评估器都是确定性的（如与真值的字符串比较）时跳过 repetitions——单次运行就是答案。

何时考虑增加稳定性：

• 同一实验的重复运行漂移幅度大于你试图测量的差异；
• 一次 prompt 变更导致的样本标签翻转与输出实际变化不符；
• judge 对同一输出的推理在不同运行间读起来不一致。

repetitions=1（默认值）恰恰依赖单次运行——不要轻信基于单个 10 样本运行得到的调参结论。

事后补充评估

from phoenix.client.experiments import evaluate_experiment evaluate_experiment(experiment=experiment, evaluators=[new_evaluator])

验证评估器准确率：用人工标签校准

评估器投入生产前必须验证（详见 validation 与 validation-evaluators-python）。技能文档中的 Key Principles 给出了量化门槛：judge 的 TPR/TNR 应 >80%。

from sklearn.metrics import classification_report print(classification_report(human_labels, evaluator_results["label"])) # Target: >80% agreement

评估器的构建决策树（来自 evaluators-overview）：

Should I Build an Evaluator? │ ▼ Can I fix it with a prompt change? YES → Fix the prompt first NO → Is this a recurring issue? YES → Build evaluator NO → Add to watchlist

不要过早自动化。很多问题只是简单的 prompt 修复。

接入测试运行器：把评估变成 CI 门禁

技能文档提供了将评估器接入 pytest 与 Vitest/Jest 的完整方案（见 integrations-pytest 与 integrations-vitest-jest）。

门禁设计核心原则：Invariants gate, signals trend

这一原则是整个 CI 门禁体系的设计哲学：

• 硬不变量（Invariants）用assert/expect把关——确定性断言（如精确匹配、格式校验）失败即 CI 变红（硬失败）；
• LLM judge 质量信号记录并聚合把关——用接受标准（acceptance criteria）对聚合指标设门槛，而不是对每个样本逐个设限（软信号，观察趋势）。

完整工作流：从观测到生产

技能文档给出了五条经过编排的标准工作流（详见 SKILL.md）：

新项目起步（Starting Fresh）：先建立观测（observe-tracing-setup）→ 错误分析（error-analysis）→ 失败分类编码（axial-coding）→ 再决定评估器（evaluators-overview）。

构建评估器（Building Evaluator）：先读基础概念（fundamentals）→ 避开常见错误（common-mistakes-python）→ 编写代码/LLM 评估器 → 用人工标签验证（validation-evaluators-{python|typescript}）。

RAG 系统（RAG Systems）：用 evaluators-rag 起步 → 代码评估器评估检索（retrieval）→ LLM 评估器评估忠实度（faithfulness）。

CI 门禁（Gating CI）：编写代码/LLM 评估器 → 接入 pytest 或 Vitest/Jest（integrations-{pytest|vitest-jest}）→ 持续生产（production-continuous）。

生产环境（Production）：production-overview → production-guardrails → production-continuous。

参考分类体系

技能文档将全部参考材料按前缀分类，方便按需查阅：

前缀	描述
fundamentals-*	类型、分数、反模式
observe-*	追踪、采样
error-analysis-*	发现失败
axial-coding-*	对失败分类编码
evaluators-*	代码、LLM、RAG 评估器
experiments-*	数据集、运行实验
integrations-*	从测试运行器（pytest、Vitest、Jest）运行评估作为 CI 门禁
validation-*	对照人工标签验证评估器准确率
production-*	CI/CD、监控

核心原则速览

技能文档的 Key Principles 是整套评估体系的方法论内核：

原则	行动
错误分析先行（Error analysis first）	未观测到的东西无法自动化
自定义优于通用（Custom > generic）	从自己的失败案例出发构建
代码优先（Code first）	先确定性，再 LLM
验证 judge（Validate judges）	TPR/TNR > 80%
二元优于量表（Binary > Likert）	pass/fail，不用 1-5 分制
不变量把关、信号看趋势（Invariants gate, signals trend）	assert/expect硬不变量（CI 变红）；记录 LLM judge 质量信号并聚合设接受标准，而非逐个样本设限

进一步探索

• 评估 API 完整实现：packages/phoenix-evals/src/phoenix/evals/evaluators.py（ScoreL159、ClassificationEvaluatorL601、create_evaluatorL828、create_classifierL1133、bind_evaluatorL1222、async_evaluate_dataframeL1559）
• 预置评估器源码：packages/phoenix-evals/src/phoenix/evals/metrics
• 实验 API：packages/phoenix-client/src/phoenix/client/experiments/init.py（run_experimentL17、evaluate_experimentL684）
• 内置评估 prompt 配置：prompts/classification_evaluator_configs
• Python 评估端到端教程：tutorials/evals/evals_quickstart.ipynb 与 tutorials/evals/evals_introduction.ipynb
• TypeScript 评估包：js/packages/phoenix-evals
• 测试参考：tests/unit/pxi（Phoenix 内部评估器测试）

赞分享

• 可观测性
• AI 评测
• LLMOps
• AI 应用
• 人工智能

【免费下载链接】phoenix

AI Observability & Evaluation

项目地址：https://gitcode.com/gh_mirrors/phoenix13/phoenix

点击查看免费下载

相关推荐

• Phoenix TypeScript LLM 评估器（Evaluators）完全指南：基于 AI SDK 的分类式评测实战

  Phoenix TypeScript LLM 评估器（Evaluators）完全指南：基于 AI SDK 的分类式评测实战 导读 本文以 Phoenix 开源仓

  可观测性AI 评测LLMOpsAI 应用人工智能

• Phoenix LLM 评估反模式清单：从错误分析到可量化改进的实战指南

  Phoenix LLM 评估反模式清单：从错误分析到可量化改进的实战指南 导读 ：本指南基于 Arize Phoenix 的 LLM 评估技能文档（ .agen

  可观测性AI 评测LLMOpsAI 应用人工智能

• Phoenix LLM Evaluators Python 指南：用 LLM 构建分类评估器与大规模评测

  Phoenix LLM Evaluators Python 指南：用 LLM 构建分类评估器与大规模评测 导读 本指南围绕 Phoenix（AI Observa

  可观测性AI 评测LLMOpsAI 应用人工智能