# 基于 SageMaker 训练作业自定义 Amazon Nova
SageMaker 训练作业是支持您大规模训练机器学习模型的环境。它可以自动预调配和扩展计算资源，从 Amazon S3 等来源加载训练数据，执行您的训练代码，并存储生成的模型构件。
训练目标是使用您的专有数据自定义基本 Amazon Nova 模型。训练过程通常涉及准备数据、选择[配方](nova-model-recipes.md)、修改 YAML 文件中的配置参数以及提交训练作业等步骤。训练过程将在服务托管的 Amazon S3 存储桶中输出经过训练的模型检查点。您可以将此检查点位置用于评估作业。基于 SageMaker AI 训练作业的 Nova 自定义，将模型构件存储在服务托管的 Amazon S3 存储桶中。服务托管存储桶中的构件使用 SageMaker AI 托管的 KMS 密钥进行加密。服务托管的 Amazon S3 存储桶目前不支持使用客户托管的 KMS 密钥进行数据加密。
## Amazon Nova 自定义最佳实践
### 概述
本节概述了自定义技术，有助您根据自身需求与可用数据选择最优方案。
#### LLM 训练的两个阶段
大型语言模型训练包括两个主要阶段：预训练和后训练。在预训练阶段，模型会处理原始文本的词元，并针对下一词元预测进行优化。此过程会产生一个模式补全器，可从网络和精选文本中学习语法、语义、事实知识和推理模式。然而，预训练模型无法理解指令、用户目标，也不具备适配上下文的行为能力。其会依据训练数据分布所涵盖的任意风格，持续生成文本。预训练模型执行的是自动补全而非遵循指令，输出格式不统一，还可能复刻训练数据中的不良偏见与不安全内容。预训练构建的是通用能力，而非任务完成能力。
后训练则可将模式补全器转化为实用助手。首先进行多轮监督式微调（SFT），通过模仿高质量的演示，教会模型遵循指令、遵守架构和策略、调用工具并生成可靠的输出。这种齐训练能让模型将提示词视为待执行的任务，而非单纯的续写文本。接着引入强化微调（RFT），利用可衡量的反馈（如验证器或 LLM-as-a-judge）来优化模型行为，在准确性与简洁性、安全性与覆盖范围，或约束条件下的多步骤推理等权衡中实现平衡。在实践中，通常采用 SFT 与 RFT 交替迭代的策略，将预训练模型打磨为一个稳定可靠、策略对齐且能一致性处理复杂任务的智能系统。
### 选择合适的自定义方法
本节将介绍后训练自定义策略：RFT 和 SFT。
#### 强化微调（RFT）
强化微调通过反馈信号（即可衡量回复质量的分数或奖励）提升模型性能，而非依靠精确标准答案进行直接监督。与从输入-输出对中学习的传统监督式微调不同，RFT 使用奖励函数评测模型响应，并迭代优化模型以最大化奖励。这种方法适用于难以定义精确输出但能可靠衡量响应质量的任务。RFT 使模型能够通过尝试和反馈来学习复杂行为与偏好，非常适合需要精细决策、创造性问题求解，或需符合可程序化评测的特定质量标准的场景。例如，回答复杂法律问题就是 RFT 的理想使用案例，因为您希望教会模型如何更好地进行推理，从而更准确地回答问题。
##### 工作原理
在强化微调中，您从经过指令微调的基线模型出发，将每个提示视作一场小型竞赛。对于给定输入，从模型中采样若干候选回答，通过奖励函数为每个回答打分并在本组内排序。更新步骤会促使模型提升高分候选回答的生成概率，降低低分回答的概率；同时通过“贴近基线”约束，避免模型行为偏移、内容冗长或钻规则漏洞。您在大量提示上重复这一循环，不断补充困难样本，在发现漏洞利用行为时强化验证器或优化评判规则，并持续跟踪任务指标。
##### 何时使用 RFT
最适合使用 RFT 的任务通常具备以下共同特征。即便难以定义唯一正确输出，仍存在可衡量的成功信号；支持部分得分或分级质量评估，因此可对同一提示下的回答进行优劣排序，或通过奖励函数完成排序；涉及多项需兼顾的目标（例如在准确性与简洁性、清晰度、安全性或成本之间取得平衡）；需要遵守可通过程序校验的明确约束；在工具介导或基于环境的环境中运行，且结果可观察（成功或失败、延迟、资源使用情况）；处于低标注数据场景，即获取标准答案成本高昂，但自动化或基于评分规则的反馈十分丰富。当您能将质量转化为可靠的标量分值或排序，并希望模型优先强化高分行为，而无需大量标注样本时，RFT 效果最佳。
**在以下情况下，建议考虑其他方法：**
+ 拥有充足且可靠的标注输入-输出对：使用 SFT
+ 主要差距在于知识或术语：使用检索增强生成（RAG）
+ 奖励信号存在噪声或不可靠，且无法通过优化评分规则或校验工具解决：在采用 RFT 之前先稳定奖励信号
##### 何时不使用 RFT
在以下情况下应避免使用 RFT：
+ 可低成本生成可靠的标注输入-输出对（SFT 更简单、低成本且更稳定）
+ 差距在于知识或术语，而非行为（建议使用 RAG）
+ 奖励信号存在噪声、稀疏、易被钻漏洞，或者计算成本高昂、速度缓慢（先优化评测器）
+ 基线性能近乎为零（先通过 SFT 完成引导，再进行偏好优化）
+ 任务具备确定性架构、严格格式要求或唯一正确答案（SFT 或基于规则的验证效果更佳）
+ 严苛的延迟或成本预算，无法承担 RFT 所需的额外采样与探索开销
+ 安全与策略约束定义不清晰，且无法在奖励函数中有效强制执行
如果能明确给出“正确答案”，请使用 SFT。如果需要补充新知识，请使用 RAG。仅当拥有稳健的基线模型，以及可靠、高效、难以被利用的奖励函数后，再使用 RFT。
#### 监督式微调（SFT）
监督式微调是在针对任务构建的人工标注输入-输出对数据集上训练 LLM。您可以提供提示（问题、指令等）示例以及正确或所需响应，并基于这些样本继续训练模型。调整模型权重以最大限度地减少监督损失（通常是其预测与目标输出词元之间的交叉熵）。这与大多数监督式机器学习任务中使用的训练方式相同，旨在对 LLM 进行专业化处理。
SFT 改变的是行为，而非知识。其不会让模型学到预训练阶段未见过的新事实或专业术语，只教会模型如何回答，而非掌握什么知识。如果需要新增领域知识（如内部术语），可在推理阶段通过检索增强生成（RAG）提供相关上下文，由 SFT 赋予模型所需的指令遵循能力。
##### 工作原理
SFT 通过最大限度地减少响应词元上的平均交叉熵损失来优化 LLM，将提示词元视为上下文并将其从损失计算中屏蔽。模型会将目标风格、结构和决策规则内化，学习为每个提示生成正确的补全。例如，要将文档分类为自定义类别，可以使用提示（文档文本）和带标签的补全（类别标签）来微调模型。您可以在这些数据对上训练模型，直到模型能够以高概率为每个提示输出正确的标签。
您可以使用少至几百个样本进行 SFT，也可以纵向扩展到几十万个样本。SFT 样本必须具备高质量，且与期望的模型行为直接对齐。
##### 何时使用 SFT
当任务定义清晰、预期输出明确时，即可使用 SFT。如果您能明确给出“输入为 X 时，正确输出为 Y”的形式，并能收集此类映射样本，监督式微调便是理想选择。SFT 在以下场景中表现出色：
+ **结构化或复杂的分类任务**：将内部文档或合同分为多个自定义类别。通过 SFT，模型对这些特定类别的学习效果要远优于仅使用提示词。
+ **具有已知答案的问答或转换任务**：微调模型以回答公司知识库中的问题，或者在格式之间转换数据，其中每个输入都有对应的正确答案。
+ **格式和风格一致性**：通过根据正确格式或语气的样本进行微调，训练模型始终以特定格式或语气做出响应。例如，在展示特定品牌语气的提示-响应对上进行训练，可以使模型学会以该风格生成输出。同样，指令遵循行为通常也是通过在精选的良好助手行为样本上进行 SFT 来初步习得。
当您可以指定正确行为是什么样子时，SFT 是教授 LLM 新技能或行为最直接的方式。其利用模型现有的语言理解能力，并将其聚焦于任务上。若希望模型执行特定任务，且已有或可构建样本数据集，即可使用 SFT。
当您能够整理出高质量、高度贴合预期行为的提示-响应对时，也适合使用 SFT。该方法适用于目标明确或格式固定的任务，例如架构、函数或工具调用，以及适合以模仿作为训练信号的结构化回答等场景。其目标是行为塑造：让模型将提示视为任务、遵循指令、采用指定语气与拒答策略，并保持输出格式一致。建议至少准备数百个示范样本，数据质量、一致性与去重比样本数量更为重要。如需实现简单且高性价比的更新，可采用低秩适应（LoRA）等参数高效微调方法训练小型适配器，同时保持基座主体参数不变。
##### 何时不使用 SFT
当差距在于知识而非行为时，不建议使用 SFT。其无法让模型学习新事实、专业术语或最新事件。此类场景应采用检索增强生成，在推理阶段引入外部知识。当您可以评估质量却无法标注唯一正确答案时，也应避免 SFT。请改用带可验证奖励或 LLM-as-a-judge 的强化微调，直接对奖励进行优化。如果需求或内容频繁变动，应依赖检索与工具使用，而非重新训练模型。
**Topics**
+ [Amazon Nova 自定义最佳实践](#best-practices)
+ [Nova Forge SDK](nova-forge-sdk.md)
+ [Amazon Nova 模型训练](smtj-training.md)
+ [监控迭代进度](nova-model-monitor.md)
+ [评估经过 SageMaker AI 训练的模型](nova-model-evaluation.md)
+ [迭代训练](smtj-iterative-training.md)
# Nova Forge SDK
Nova Forge SDK 是一套功能完整的 Python SDK，专用于 Amazon Nova 模型的自定义开发。该 SDK 为跨不同平台（包括 SageMaker AI 和 Amazon Bedrock）的 Amazon Nova 模型，提供了训练、评估、监控、部署及推理的统一接口。无论是针对特定领域任务适配模型，还是根据自身使用案例优化性能，该 SDK 都能在单一统一接口中提供您所需的全部功能。
## 优势
+ 一款 SDK 覆盖全流程模型自定义生命周期：从数据准备到部署与监控。
+ 支持多种训练方法，包括持续预训练（CPT）、监督式微调（SFT）、直接偏好优化（DPO）、强化微调（RFT）；同时支持单轮/多轮对话场景，以及 LoRA 与全秩适配方式。
+ 为 SageMaker 训练作业、SageMaker HyperPod 和 Amazon Bedrock 提供内置支持，且可实现自动资源管理。
+ 无需再为训练方法查找适配的配方或容器 URI。
+ 支持自备训练配方，也可使用 SDK 智能默认值并覆盖参数。
+ 该 SDK 会依据支持的模型与实例组合对配置进行校验，并提供验证支持，从而在训练启动前规避错误。
+ 集成 Amazon CloudWatch 监控功能，支持实时追踪训练进度。
+ 集成 MLflow，可通过 SageMaker AI MLflow 跟踪服务器追踪训练实验。
## 要求
该 SDK 要求的最低 Python 版本为 3.12。
## 安装
如需安装该 SDK，请执行以下命令。
```
pip install amzn-nova-forge
```
## 支持的模型与技术
该 SDK 支持 Amazon Nova 系列中的以下模型与技术：
****
| 方法 | 支持的模型 |
| --- | --- |
| 持续预训练 | [所有 Nova 模型](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-recipes.html#nova-model-recipes-reference)（仅限 SMHP） |
| 监督式微调 LoRA | [所有 Nova 模型](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-recipes.html#nova-model-recipes-reference) |
| 全秩监督式微调 | [所有 Nova 模型](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-recipes.html#nova-model-recipes-reference)（仅限 SMHP 和 SMTJ） |
| 直接偏好优化 LoRA | Nova 1.0 模型（仅限 SMHP 和 SMTJ） |
| 全秩直接偏好优化 | Nova 1.0 模型（仅限 SMHP 和 SMTJ） |
| 强化微调 LoRA | Nova Lite 2.0 |
| 全秩强化微调 | Nova Lite 2.0（仅限 SMHP 和 SMTJ） |
| 多轮强化微调 LoRA | Nova Lite 2.0（仅限 SMHP） |
| 全秩多轮强化微调 | Nova Lite 2.0（仅限 SMHP） |
## 开始使用
**Topics**
+ [1. 准备数据](#nova-forge-sdk-prepare-data)
+ [2. 配置基础设施](#nova-forge-sdk-configure-infrastructure)
+ [3. 训练](#nova-forge-sdk-train)
+ [4. 监控](#nova-forge-sdk-monitor)
+ [5. 评估](#nova-forge-sdk-evaluate)
+ [6. 部署](#nova-forge-sdk-deploy)
### 1. 准备数据
从本地文件或 S3 加载数据集后，SDK 会自动将其转换为所选训练方法对应的标准格式。您也可直接提供已格式化的数据，快速启动训练流程。
```
from amzn_nova_forge.dataset.dataset_loader import JSONLDatasetLoader
from amzn_nova_forge.model.model_enums import Model, TrainingMethod
loader = JSONLDatasetLoader(question="input", answer="output")
loader.load("s3://your-bucket/training-data.jsonl")
loader.transform(method=TrainingMethod.SFT_LORA, model=Model.NOVA_LITE)
```
### 2. 配置基础设施
选定计算资源，SDK 自动验证配置，保障最优部署。
```
from amzn_nova_forge.manager.runtime_manager import BedrockRuntimeManager, SMTJRuntimeManager, SMHPRuntimeManager
# Bedrock
runtime = BedrockRuntimeManager(
execution_role="arn:aws:iam::123456789012:role/ExampleRole"
)
# SageMaker Training Jobs
runtime = SMTJRuntimeManager(
instance_type="ml.p5.48xlarge",
instance_count=4
)
# SageMaker HyperPod
runtime = SMHPRuntimeManager(
instance_type="ml.p5.48xlarge",
instance_count=4,
cluster_name="my-hyperpod-cluster",
namespace="kubeflow"
)
```
### 3. 训练
仅需几行代码即可启动训练。
```
from amzn_nova_forge.model import NovaModelCustomizer
from amzn_nova_forge.model.model_enums import Model, TrainingMethod
customizer = NovaModelCustomizer(
model=Model.NOVA_LITE_2,
method=TrainingMethod.SFT_LORA,
infra=runtime,
data_s3_path="s3://your-bucket/prepared-data.jsonl"
)
result = customizer.train(job_name="my-training-job")
```
### 4. 监控
您可直接通过 SDK 追踪训练进度。
```
from amzn_nova_forge.monitor.log_monitor import CloudWatchLogMonitor
# Monitor training logs
customizer.get_logs()
# Or monitor directly via CloudWatchLogMonitor
monitor = CloudWatchLogMonitor.from_job_result(result)
monitor.show_logs(limit=10)
# Check job status
result.get_job_status() # InProgress, Completed, Failed
```
### 5. 评估
通过多种[内置基准](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-benchmark)评估模型性能，也可自定义评估方案。
```
from amzn_nova_forge.recipe_config.eval_config import EvaluationTask
# Evaluate on benchmark tasks
eval_result = customizer.evaluate(
job_name="model-eval",
eval_task=EvaluationTask.MMLU,
model_path=result.model_artifacts.checkpoint_s3_path
)
```
### 6. 部署
借助内置的 Amazon Bedrock 或 SageMaker 适配能力，可将自定义模型部署到生产环境。
```
from amzn_nova_forge.model.model_enums import DeployPlatform
# Bedrock provisioned throughput
deployment = customizer.deploy(
model_artifact_path=result.model_artifacts.checkpoint_s3_path,
deploy_platform=DeployPlatform.BEDROCK_PT,
pt_units=10
)
# Bedrock On-Demand
deployment = customizer.deploy(
model_artifact_path=result.model_artifacts.checkpoint_s3_path,
deploy_platform=DeployPlatform.BEDROCK_OD,
pt_units=10
)
# Sagemaker Real-time Inference
deployment = customizer.deploy(
model_artifact_path=result.model_artifacts.checkpoint_s3_path,
deploy_platform=DeployPlatform.SAGEMAKER,
unit_count=10,
sagemaker_instance_type="ml.p5.48xlarge",
sagemaker_environment_variables={
"CONTEXT_LENGTH": "12000",
"MAX_CONCURRENCY": "16",
}
)
```
## 关键功能
### 动态配方生成
该 SDK 无需您为特定训练方法查找适配的配方或容器 URI。
### 智能数据处理
该 SDK 会自动将数据转换为训练所需的标准格式。无论您使用 JSON、JSONL 或 CSV 文件，数据加载器均可无缝完成格式转换。数据加载器同时支持文本数据及多模态数据（图像和视频）。
### 企业级基础设施支持
该 SDK 可兼容 SageMaker 训练作业与 SageMaker HyperPod，并自动管理以下内容：
+ 实例类型验证
+ 配方验证
+ 数据集验证
+ 作业编排与监控
该 SDK 还支持 SageMaker 训练作业无服务器模式和 Bedrock 自定义功能。
### 全面评测
基于行业[标准基准](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-hp-evaluate.html)评测自定义模型，包括：
+ MMLU（大规模多任务语言理解）
+ BBH（高级推理任务）
+ GPQA（Google 无法解答的研究生级别问答基准）
您可直接使用基准默认配置，或根据需求自行定义：
+ BYOM（自定义指标）
+ BYOD（自定义数据集）
### 生产环境部署
将模型部署到 Amazon Bedrock 或 SageMaker AI，支持以下部署方式：
+ **Bedrock 预置吞吐量**：提供专属算力，保障性能稳定
+ **Bedrock 按需调用（仅适用于基于 LoRA 的自定义）**：按需付费
+ **SageMaker AI 实时推理**：提供专属算力，保障性能稳定
### 批量推理
高效运行大规模推理作业：
+ 并行处理数千个请求
+ 结果自动聚合
+ 高性价比批量处理
### Nova Forge
对于 Nova Forge 订阅用户，该 SDK 支持数据混合配方。
## 了解更多
准备好开始使用 Nova Forge SDK 来自定义 Nova 模型了吗？ 前往我们的 GitHub 存储库，查看详细指南、API 参考及更多示例：：[https://github.com/aws/nova-forge-sdk](https://github.com/aws/nova-forge-sdk)
# Amazon Nova 模型训练
通过 SageMaker 训练作业对 Amazon Nova 模型进行训练，支持监督式微调（SFT）与强化微调（RFT）。每种技术适用于不同的自定义需求，并可应用于不同版本的 Amazon Nova 模型。
**Topics**
+ [微调 Nova 2.0](nova-fine-tune-2.md)
+ [使用 Amazon Nova 模型进行强化微调（RFT）](nova-reinforcement-fine-tuning.md)
# 微调 Nova 2.0
## 先决条件
在开始训练作业之前，请注意具备以下内容：
+ Amazon S3 存储桶，用于存储您的输入数据和训练作业的输出。您可以为这两者使用一个存储桶，也可以为每种类型的数据使用不同的存储桶。确保您的存储桶位于您创建所有其他训练资源所用的 AWS 区域。有关更多信息，请参阅[创建通用存储桶](https://docs.aws.amazon.com//AmazonS3/latest/userguide/create-bucket-overview.html)。
+ 具有运行训练作业权限的 IAM 角色。请务必为 IAM 策略附加 `AmazonSageMakerFullAccess`。有关更多信息，请参阅[如何使用 SageMaker AI 执行角色](https://docs.aws.amazon.com//sagemaker/latest/dg/sagemaker-roles.html)。
+ 基本 Amazon Nova 配方，请参阅[获取 Amazon Nova 配方](nova-model-recipes.md#nova-model-get-recipes)。
## 什么是 SFT？
监督式微调（SFT）使用带标注的输入-输出对训练语言模型。模型从包含提示和响应的示范示例中学习，优化能力以适配特定任务、指令或预期行为。
## 数据准备
### 概述
Nova 2.0 SFT 数据采用与 Nova 1.0 相同的 Converse API 格式，并新增了可选的推理内容字段。如需完整格式规范，请参阅：
+ 推理内容：[ReasoningContentBlock](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_ReasoningContentBlock.html)
+ Converse API 架构：[Converse API](https://docs.aws.amazon.com/bedrock/latest/userguide/conversation-inference-call.html)
+ 数据集约束：[数据集约束](https://docs.aws.amazon.com/nova/latest/userguide/fine-tune-prepare-data-understanding.html)
### 支持的功能
+ **输入类型**：用户内容块中的文本、图像或视频
+ **助手内容**：纯文本响应和推理内容
+ **数据集构成**：必须为同构数据。选择如下选项之一：
+ 纯文本轮次
+ 文本 \$1 图像轮次
+ 文本 \$1 视频轮次（支持文档理解）
**重要**
不得在同一数据集中或不同对话轮次间混合使用图像和视频。
### 目前的局限性
+ **多模态推理内容**：虽然 Converse 格式支持基于图像的推理内容，但 Nova 2.0 SFT 仅支持 reasoningText 字段中基于文本的推理内容。
+ **验证集**：Nova 2.0 的 SFT 训练不支持提供验证数据集。若传入验证数据集，训练过程中将被忽略。该限制同时适用于基于 UI 提交和程序化提交的训练作业。
### 支持的媒体格式
+ **图像**：PNG、JPEG、GIF
+ **视频**：MOV、MKV、MP4
### 数据格式示例
------
#### [ Text-only (Nova 1.0 compatible) ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a digital assistant with a friendly personality"
}
],
"messages": [
{
"role": "user",
"content": [
{
"text": "What country is right next to Australia?"
}
]
},
{
"role": "assistant",
"content": [
{
"text": "The closest country is New Zealand"
}
]
}
]
}
```
------
#### [ Text with reasoning (Nova 2.0) ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a digital assistant with a friendly personality"
}
],
"messages": [
{
"role": "user",
"content": [
{
"text": "What country is right next to Australia?"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I need to use my world knowledge of geography to answer this question"
}
}
},
{
"text": "The closest country to Australia is New Zealand, located to the southeast across the Tasman Sea."
}
]
}
]
}
```
------
#### [ Image \$1 text input ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a helpful assistant."
}
],
"messages": [
{
"role": "user",
"content": [
{
"image": {
"format": "jpeg",
"source": {
"s3Location": {
"uri": "s3://your-bucket/your-path/your-image.jpg",
"bucketOwner": "your-aws-account-id"
}
}
}
},
{
"text": "Which country is highlighted in the image?"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I will determine the highlighted country by examining its location on the map and using my geographical knowledge"
}
}
},
{
"text": "The highlighted country is New Zealand"
}
]
}
]
}
```
------
#### [ Video \$1 text input ]
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are a helpful assistant."
}
],
"messages": [
{
"role": "user",
"content": [
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://your-bucket/your-path/your-video.mp4",
"bucketOwner": "your-aws-account-id"
}
}
}
},
{
"text": "What is shown in this video?"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I will analyze the video content to identify key elements"
}
}
},
{
"text": "The video shows a map with New Zealand highlighted"
}
]
}
]
}
```
------
## 工具调用
Nova 2.0 SFT 支持基于工具调用模式进行模型训练，使模型能够学习何时以及如何调用外部工具或函数。
### 工具调用的数据格式
工具调用训练数据包含用于定义可用工具的 `toolConfig` 部分，以及展示工具使用模式的对话轮次内容。
**示例输入**
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are an expert in composing function calls."
}
],
"toolConfig": {
"tools": [
{
"toolSpec": {
"name": "getItemCost",
"description": "Retrieve the cost of an item from the catalog",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"item_name": {
"type": "string",
"description": "The name of the item to retrieve cost for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to retrieve cost for"
}
},
"required": [
"item_id"
]
}
}
}
},
{
"toolSpec": {
"name": "getItemAvailability",
"description": "Retrieve whether an item is available in a given location",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"zipcode": {
"type": "string",
"description": "The zipcode of the location to check in"
},
"quantity": {
"type": "integer",
"description": "The number of items to check availability for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to check availability for"
}
},
"required": [
"item_id", "zipcode"
]
}
}
}
}
]
},
"messages": [
{
"role": "user",
"content": [
{
"text": "I need to check whether there are twenty pieces of the following item available. Here is the item ASIN on Amazon: id-123. Please check for the zipcode 94086"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "The user wants to check how many pieces of the item with ASIN id-123 are available in the zipcode 94086"
}
}
},
{
"toolUse": {
"toolUseId": "getItemAvailability_0",
"name": "getItemAvailability",
"input": {
"zipcode": "94086",
"quantity": 20,
"item_id": "id-123"
}
}
}
]
},
{
"role": "user",
"content": [
{
"toolResult": {
"toolUseId": "getItemAvailability_0",
"content": [
{
"text": "[{\"name\": \"getItemAvailability\", \"results\": {\"availability\": true}}]"
}
]
}
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Yes, there are twenty pieces of item id-123 available at 94086. Would you like to place an order or know the total cost?"
}
]
}
]
}
```
### 工具调用要求
创建工具调用训练数据时，请遵循以下要求：
| 要求 | 说明 |
| --- | --- |
| ToolUse 放置 | ToolUse 只能出现在助手轮次中 |
| ToolResult 放置 | ToolResult 只能出现在用户轮次中 |
| ToolResult 格式 | ToolResult 只能为文本或 JSON。Nova 模型不支持其他模态 |
| inputSchema 格式 | toolSpec 中的 inputSchema 必须是有效的 JSON 架构对象 |
| toolUseId 匹配 | 每个 ToolResult 必须引用前序助手轮次 ToolUse 中的有效 toolUseId，且每个 toolUseId 在单次对话中仅可使用一次 |
### 重要提示
+ 确保工具定义在所有训练样本中保持一致
+ 模型将从所提供的示例中学习工具调用模式
+ 包含各类场景示例，明确各工具的适用与不适用情况
## 文档理解
Nova 2.0 SFT 支持基于文档任务的训练，使模型能够学习如何分析并回答与 PDF 文档相关的问题。
### 文档理解数据格式
文档理解训练数据在用户内容块中包含文档引用，模型将学习对文档内容进行提取与推理。
**示例输入**
```
{
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"document": {
"format": "pdf",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/documents/customer_service_debugging.pdf",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I need to find the relevant section in the document to answer the question."
}
}
},
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
]
}
]
}
}
```
### 文档理解限制
| 限制 | Details |
| --- | --- |
| 支持的格式 | 仅支持 PDF 文件 |
| 最大文档大小 | 10 MB |
| 模态混合 | 单个样本可包含文档与文本，但不可将文档与其他模态（图像、视频）混用 |
### 文档理解最佳实践
+ 确保文档格式清晰，文本可正常提取
+ 提供覆盖不同文档类型与问题格式的多样化样本
+ 包含推理内容，帮助模型学习文档分析模式
## 视频理解
Nova 2.0 SFT 支持基于视频任务的训练，使模型能够学习如何分析并回答与视频内容相关的问题。
### 视频理解数据格式
视频理解训练数据在用户内容块中包含视频引用，模型将学习从视频内容中提取信息并进行推理。
**示例输入**
```
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/videos/customer_service_debugging.mp4",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "I need to find the relevant section in the video to answer the question."
}
}
},
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
]
}
]
}
```
### 视频理解限制
| 限制 | Details |
| --- | --- |
| 最大视频大小 | 50 MB |
| 视频最长时长 | 15 分钟 |
| 单个样本视频数量 | 每个样本仅允许包含一个视频，不支持在同一样本中使用多个视频 |
| 模态混合 | 单个样本可包含视频与文本，但不可将视频与其他模态（图像、文档）混用 |
### 支持的视频格式
+ MOV
+ MKV
+ MP4
### 视频理解最佳实践
+ 保持视频简洁明了，聚焦与任务相关的内容
+ 确保视频画质清晰，便于模型提取有效信息
+ 提出的问题应明确指向视频中的特定内容
+ 提供覆盖不同视频类型与问题格式的多样化样本
## 推理模式与非推理模式
### 理解推理内容
推理内容（亦称思维链）会记录模型在生成最终答案前的中间思考步骤。在 `assistant` 轮次中，可通过 `reasoningContent` 字段加入这些推理轨迹。
**损失计算方式**
+ **包含推理内容**：训练损失同时计入推理词元和最终输出词元
+ **不含推理内容**：训练损失仅基于最终输出词元计算
您可在多轮对话的多个助手轮次中添加 `reasoningContent`。
**格式规范**
+ 推理内容使用纯文本
+ 除非任务明确要求，否则避免使用 `` 和 `` 等标记标签
+ 确保推理内容清晰，并与问题求解过程相关
### 何时启用推理模式
在以下场景中，在训练配置里设置 `reasoning_enabled: true`：
+ 训练数据包含推理词元
+ 希望模型在生成最终输出前先产生思考词元
+ 需要在复杂推理任务上获得更优性能
允许在 `reasoning_enabled = true` 的情况下，使用非推理数据集训练 Nova。但是，这样做可能会导致模型丧失推理能力，因为 Nova 主要学习数据中呈现的应答方式，而非执行推理过程。如果希望使用非推理数据集训练，同时在推理阶段保留推理能力，则可在训练时关闭推理 (`reasoning_enabled = false`)，并在推理时启用。这种方式虽能在推理时使用推理，但无法保证效果优于不启用推理的推理方式。一般建议：使用推理数据集时，训练与推理均启用推理；使用非推理数据集时，两者均关闭推理。
在以下场景中，设置 `reasoning_enabled: false`：
+ 训练数据不包含推理词元
+ 训练任务较为简单，无需显式推理步骤
+ 希望优化速度并减少词元使用量
### 生成推理数据
如果数据集缺失推理轨迹，可借助 Nova Premier 等具备推理能力的模型来生成。将输入-输出对提供给模型，记录其推理过程，从而构建包含推理内容的增强型数据集。
### 使用推理词元进行训练
启用推理模式进行训练时，模型会学习将内部推理过程与最终答案分离开。训练过程：
+ 将数据组织为三元组结构：输入、推理和答案
+ 基于推理词元和答案词元的标准下一词元预测损失进行优化
+ 引导模型在生成回复前先进行内部逻辑推理
### 优质推理内容的要素
高质量的推理内容应包含以下要素：
+ 中间思考与分析
+ 逻辑推导与推理步骤
+ 分步解决问题的方法
+ 推理步骤与结论之间的明确关联
这些要素有助于模型掌握“先思考，后作答”的能力。
## 数据集准备指南
### 规模与质量
+ **推荐样本量**：2000 – 10000 个样本
+ **最小样本量**：200
+ **优先级**：质量胜于数量。确保样本准确、标注规范
+ **应用贴合度**：数据集应尽可能贴近实际使用案例
### 多样性
样本需具备多样性，满足以下要求：
+ 覆盖所有预期输入类型
+ 包含不同难度级别的样本
+ 纳入边界情况与各类变体
+ 避免模型过拟合于单一模式
### 输出格式
在助手响应中明确指定所需输出格式：
+ JSON 结构
+ 表
+ CSV 格式
+ 应用程序专属的自定义格式
### 多回合对话
使用多轮对话数据集时请注意：
+ 损失仅基于助手轮次计算，而非用户轮次
+ 每个助手响应都应格式正确
+ 保持各轮对话风格与格式一致
### 质量检查清单
+ 数据集规模充足（2000 – 10000 个样本）
+ 涵盖所有使用案例的多样化样本
+ 输出格式清晰统一
+ 标签与标注准确无误
+ 贴合实际生产场景
+ 无矛盾或歧义内容
### 上传数据
数据集需上传到 SageMaker 训练作业可访问的存储桶。有关设置相应权限的信息，请参阅[先决条件](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-general-prerequisites.html)。
## 启动训练作业
### 选择超参数并更新配方
Nova 2.0 的设置方式与 Nova 1.0 基本一致。将输入数据上传到 S3 后，使用 [SageMaker HyperPod Recipes](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/nova) 中 fine-tuning 文件夹下的配方。对于 Nova 2.0，以下是一些可以根据使用案例更新的关键超参数。以下是 Nova 2.0 SFT PEFT 配方的样本。对于容器映像 URI，请使用 `708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-TJ-SFT-V2-latest` 来运行 SFT 微调作业。
请使用 v2.254.1 版本的 SageMaker AI PySDK，确保与 Nova 训练严格兼容。将 SDK 升级到 v3.0 版本会导致破坏性变更。对 SageMaker AI PySDK v3 的支持即将推出。
**示例输入**
```
!pip install sagemaker==2.254.1
```
```
run:
name: {peft_recipe_job_name}
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: {peft_model_name_or_path}
data_s3_path: {train_dataset_s3_path} # SageMaker HyperPod (SMHP) only and not compatible with SageMaker Training jobs. Note replace my-bucket-name with your real bucket name for SMHP job
replicas: 4 # Number of compute instances for training, allowed values are 4, 8, 16, 32
output_s3_path: "" # Output artifact path (Hyperpod job-specific; not compatible with standard SageMaker Training jobs). Note replace my-bucket-name with your real bucket name for SMHP job
training_config:
max_steps: 10 # Maximum training steps. Minimal is 4.
save_steps: 10 # How many training steps the checkpoint will be saved. Should be less than or equal to max_steps
save_top_k: 1 # Keep top K best checkpoints. Note supported only for SageMaker HyperPod jobs. Minimal is 1.
max_length: 32768 # Sequence length (options: 8192, 16384, 32768 [default], 65536)
global_batch_size: 32 # Global batch size (options: 32, 64, 128)
reasoning_enabled: true # If data has reasoningContent, set to true; otherwise False
lr_scheduler:
warmup_steps: 15 # Learning rate warmup steps. Recommend 15% of max_steps
min_lr: 1e-6 # Minimum learning rate, must be between 0.0 and 1.0
optim_config: # Optimizer settings
lr: 1e-5 # Learning rate, must be between 0.0 and 1.0
weight_decay: 0.0 # L2 regularization strength, must be between 0.0 and 1.0
adam_beta1: 0.9 # Exponential decay rate for first-moment estimates, must be between 0.0 and 1.0
adam_beta2: 0.95 # Exponential decay rate for second-moment estimates, must be between 0.0 and 1.0
peft: # Parameter-efficient fine-tuning (LoRA)
peft_scheme: "lora" # Enable LoRA for PEFT
lora_tuning:
alpha: 64 # Scaling factor for LoRA weights ( options: 32, 64, 96, 128, 160, 192),
lora_plus_lr_ratio: 64.0
```
该配方包含的超参数与 Nova 1.0 基本一致。核心超参数如下：
+ `max_steps`：希望作业运行的步数。通常，1 轮 epoch（遍历完整数据集一次）的计算方式为：步数 = 数据样本数/全局批次大小。步数越大、全局批次越小，任务运行耗时越长。
+ `reasoning_enabled`：控制数据集的推理模式。选项：
+ `true`：启用推理模式（相当于高强度推理）
+ `false`：禁用推理模式
注意：在 SFT 中，无法精细控制推理强度。设置 `reasoning_enabled: true` 即启用完整推理能力。
+ `peft.peft_scheme`：设置为“lora”即启用基于 PEFT 的微调。设置为 null（不带引号）即启用全秩微调。
### 启动训练作业
```
from sagemaker.pytorch import PyTorch
# define OutputDataConfig path
if default_prefix:
output_path = f"s3://{bucket_name}/{default_prefix}/{sm_training_job_name}"
else:
output_path = f"s3://{bucket_name}/{sm_training_job_name}"
output_kms_key = "" # optional, leave blank for Amazon managed encryption
recipe_overrides = {
"run": {
"replicas": instance_count, # Required
"output_s3_path": output_path
},
}
estimator = PyTorch(
output_path=output_path,
base_job_name=sm_training_job_name,
role=role,
disable_profiler=True,
debugger_hook_config=False,
instance_count=instance_count,
instance_type=instance_type,
training_recipe=training_recipe,
recipe_overrides=recipe_overrides,
max_run=432000,
sagemaker_session=sagemaker_session,
image_uri=image_uri,
output_kms_key=output_kms_key,
tags=[
{'Key': 'model_name_or_path', 'Value': model_name_or_path},
]
)
print(f"\nsm_training_job_name:\n{sm_training_job_name}\n")
print(f"output_path:\n{output_path}")
```
```
from sagemaker.inputs import TrainingInput
train_input = TrainingInput(
s3_data=train_dataset_s3_path,
distribution="FullyReplicated",
s3_data_type="Converse",
)
estimator.fit(inputs={"validation": val_input}, wait=False)
```
**注意**
Nova 2.0 的监督式微调不支持传递验证数据集。
要启动作业，请执行以下操作：
+ 更新配方中的数据集路径与超参数
+ 运行笔记本中指定的代码单元，提交训练作业
笔记本将自动处理作业提交，并提供状态跟踪功能。
# 使用 Amazon Nova 模型进行强化微调（RFT）
## 概述
**什么是 RFT？**
强化微调（RFT）通过基于反馈信号（即指示模型表现优劣的可衡量分数或奖励）的训练来提升模型性能，而不是基于精确的正确答案。与从输入-输出对中学习的监督式微调不同，RFT 使用奖励函数来评测模型响应，并迭代优化模型以获得最高奖励。这种方法适用于难以定义精确输出但能可靠衡量响应质量的任务。
**何时使用 RFT**
当您能够定义清晰、可衡量的成功标准，但难以提供精确的正确输出用于训练时，便可使用 RFT。该方法适用于：
+ 质量具有主观性或多维度的任务，如创意写作、代码优化或复杂推理
+ 存在多种可行方案，但部分方案明显更优的场景
+ 需要迭代改进、个性化或遵循复杂业务规则的应用
+ 收集高质量标注样本成本过高或不切实际的情况
**最佳使用案例**
在输出质量可客观衡量、但最优应答难以预先定义的领域，RFT 表现优异：
+ 数学问题求解和代码生成
+ 科学推理与结构化数据分析
+ 需要逐步推理或多轮问题求解的任务
+ 兼顾多个目标（准确率、效率、风格）的应用
+ 可通过执行结果或性能指标以编程方式验证成功与否的场景
**支持的模型**
Nova Lite 2.0
## 数据格式概述
RFT 训练数据必须遵循 OpenAI 强化微调[格式](https://platform.openai.com/docs/api-reference/fine-tuning/reinforcement-input)。每个训练样本都是一个 JSON 对象，其中包含：
+ 包含 `system` 和 `user` 角色对话轮次的 `messages` 数组
+ 包含用于奖励计算的期望输出或评测标准的 `reference_answer` 字段
**目前的局限性**
+ 仅文本
### 数据格式示例
每个样本需单独占一行，JSONL 文件中每行对应一个 JSON 对象。
------
#### [ Chemistry problem ]
```
{
"id": "chem-01",
"messages": [
{
"role": "system",
"content": "You are a helpful chemistry assistant"
},
{
"role": "user",
"content": "Calculate the molecular weight of caffeine (C8H10N4O2)"
}
],
"reference_answer": {
"molecular_weight": 194.19,
"unit": "g/mol",
"calculation": "8(12.01) + 10(1.008) + 4(14.01) + 2(16.00) = 194.19"
}
}
```
------
#### [ Math problem ]
```
{
"id": "sample-001", // Optional
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
}
}
```
------
#### [ Code problem ]
```
{
"id": "code-002",
"messages": [
{
"role": "system",
"content": "You are a helpful programming assistant"
},
{
"role": "user",
"content": "Write a Python function that reverses a string without using built-in reverse methods"
}
],
"reference_answer": {
"code": "def reverse_string(s): \n result = '' \n for i in range(len(s) - 1, -1, -1): \n result += s[i] \n return result",
"test_cases": [
{
"input": "hello",
"expected_output": "olleh"
},
{
"input": "",
"expected_output": ""
},
{
"input": "a",
"expected_output": "a"
},
{
"input": "Python123",
"expected_output": "321nohtyP"
}
],
"all_tests_pass": true
}
}
```
------
`reference_answer` 字段包含期望输出或评测标准，供奖励函数对模型响应进行评分。其不限于结构化输出，可采用任何有助于奖励函数评测质量的格式。
## 数据集规模建议
**起步要求**
+ 至少 100 个训练样本
+ 至少 100 个评测样本
**评测优先的方法**
在投入大规模 RFT 训练之前，请先评测模型的基线性能：
+ **性能优异（奖励大于 95%）**：无需进行 RFT，模型表现足够好
+ **性能极差（奖励为 0%）**：先切换到 SFT，建立基本能力
+ **性能中等**：适合采用 RFT 训练
从小规模数据集开始，可实现以下效果：
+ 验证奖励函数无错误
+ 确认 RFT 适合于使用案例
+ 尽早发现并修复问题
+ 在扩展规模前测试工作流
验证通过后，即可扩展到更大规模的数据集，进一步提升模型性能。
## 有效训练数据的特征
**清晰性与一致性**
优质的 RFT 样本需要清晰、无歧义的输入数据，以便能够针对不同的模型输出进行准确的奖励计算。数据中应避免以下干扰：
+ 格式不一致
+ 标签或指令相互矛盾
+ 提示词含义模糊
+ 参考答案互相冲突
任何歧义都会误导训练过程，导致模型学习到非预期的行为。
**多样性**
数据集应覆盖生产环境中的各类使用案例，确保模型在真实环境中表现稳健。包含：
+ 不同的输入格式和边界情况
+ 从日志和用户分析中映射实际的生产使用模式
+ 跨用户类型、地理区域和季节性变化的采样
+ 包含从简单到复杂的问题难度级别
**奖励函数注意事项**
设计奖励函数，实现高效训练：
+ 在几秒钟内执行完毕（而非几分钟）
+ 使用 Lambda 实现高效并行
+ 返回一致且可靠的分数
+ 妥善处理不同类型的模型输出
快速且可扩展的奖励函数可支持快速迭代，并在实验中实现高成本效益。
## 其它属性
RFT 数据格式支持核心架构要求（`messages` 和 `reference_answer`）之外的自定义字段。这种灵活性支持您添加奖励函数完成有效评测所需的任意附加数据。
**注意**
无需在配方中进行配置，该数据格式原生支持附加字段。只需将其包含在训练数据的 JSON 中，即可通过 `metadata` 字段传递给奖励函数。
**常见附加属性**
元数据字段示例：
+ `task_id`：用于跟踪的唯一标识符
+ `difficulty_level`：问题复杂度指示符
+ `domain`：主题领域或类别
+ `expected_reasoning_steps`：解题过程中的步骤数
**包含其他属性的示例**
```
{
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
},
"task_id": "algebra_001",
"difficulty_level": "easy",
"domain": "algebra",
"expected_reasoning_steps": 3
}
```
这些附加字段将在评测期间传递给奖励函数，从而实现针对特定使用案例量身定制的复杂评分逻辑。
## 训练配置
**配方示例**
```
# Note:
# This recipe can run on p5.48xlarge and p5en.48xlarge instance types.
run:
name: "my-rft-run" # Unique run name (appears in logs/artifacts).
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod
data_s3_path: s3:/// # Training dataset in JSONL;
replicas: 4
reward_lambda_arn: arn:aws:lambda:::function:
## MLFlow configs
mlflow_tracking_uri: "" # Required for MLFlow
mlflow_experiment_name: "my-rft-experiment" # Optional for MLFlow. Note: leave this field non-empty
mlflow_run_name: "my-rft-run" # Optional for MLFlow. Note: leave this field non-empty
## SMTJ GRPO Training specific configs
training_config:
max_length: 8192 # Context window (tokens) for inputs+prompt;
global_batch_size: 16 # Total samples per optimizer step across all replicas (16/32/64/128/256).
reasoning_effort: high # Enables reasoning mode high / low / or null for non-reasoning
rollout: # How responses are generated for GRPO/advantage calc.
advantage_strategy:
number_generation: 2 # N samples per prompt to estimate advantages (variance vs cost).
generator:
max_new_tokens: 6000 # Cap on tokens generated per sample
set_random_seed: true # Seed generation for reproducibility across runs.
temperature: 1 # Softmax temperature;
top_k: 1 # Sample only from top-K logits
rewards:
preset_reward_function: null # Usage of preset reward functions [exact_match]
api_endpoint:
lambda_arn: arn:aws:lambda:::function:
lambda_concurrency_limit: 12 # Max concurrent Lambda invocations (throughput vs. throttling).
trainer:
max_steps: 2 # Steps to train for. One Step = global_batch_size
save_steps: 5
test_steps: 1
# RL parameters
ent_coeff: 0.0 # A bonus added to the policy loss that rewards higher-output entropy.
kl_loss_coef: 0.001 # Weight on the KL penalty between the actor (trainable policy) and a frozen reference model
optim_config: # Optimizer settings
lr: 5e-5 # Learning rate
weight_decay: 0.0 # L2 regularization strength (0.0–1.0)
adam_beta1: 0.9
adam_beta2: 0.95
peft: # Parameter-efficient fine-tuning (LoRA)
peft_scheme: "lora" # Enable LoRA for PEFT
lora_tuning:
alpha: 32
lora_plus_lr_ratio: 64.0 # LoRA+ learning rate scaling factor (0.0–100.0)
```
## 使用 LLM-as-a-judge 的 RFT 训练
### 概述
大语言模型（LLM）越来越多地被用作强化微调（RFT）工作流中的评判工具，提供自动化的奖励信号来指导模型优化。在这种方法中，LLM 会根据指定标准对模型输出进行评测（包括正确性、质量、风格一致性或语义等效性等），并分配用于驱动强化学习过程的奖励值。
对于传统奖励函数难以通过编程定义的任务，该方法尤为实用。例如判断不同表达形式（如“1/3”“0.333”和“三分之一”）是否语义等效，或评测连贯性、相关性等细微特征。通过将基于 LLM 的评判机制作为奖励函数，可将 RFT 扩展到复杂领域，无需大量人工标注，进而在传统对齐问题之外的各类场景中，实现模型的快速迭代与持续优化。
### 推理模式选择
**可用模式**
+ none：无推理（省略 reasoning\$1effort 字段）
+ low：最小推理开销
+ high：最大推理能力（指定了 reasoning\$1effort 时，此为默认值）
**注意**
RFT 无中等选项。如果配置中不含 reasoning\$1effort 字段，则禁用推理。启用推理时，建议将 `max_new_tokens` 设置为 32768，以容纳更长的推理输出内容。
**何时使用各个模式**
在以下场景使用高强度推理：
+ 复杂分析任务
+ 数学问题求解
+ 多步逻辑推导
+ 逐步思考能带来价值的任务
在以下场景使用无推理（省略 reasoning\$1effort）或低强度推理：
+ 简单事实查询
+ 直接分类
+ 速度与成本优化
+ 直接问答
**成本与性能权衡**
较高强度推理模式会导致：
+ 训练时间和成本增加
+ 推理延迟和成本增加
+ 模型在复杂推理任务上的能力提升
### 验证 LLM 评判工具
在生产中部署 LLM-as-a-judge 之前，请验证评判工具模型的评测是否与人类判断一致。这涉及：
+ 测量 LLM 评判工具与人工评测员在任务代表性样本上的一致率
+ 确保 LLM 与人类评测的一致率达到或超过人类之间的一致率
+ 识别评判工具模型中可能存在的偏差
+ 建立信心，确保奖励信号能按预期方向引导模型
此验证步骤有助于确保自动化评测过程能够产生符合生产质量标准的模型。
### LLM 评判工具的 Lambda 配置
采用 LLM-as-a-judge，是对使用 Lambda 函数实现可验证奖励强化学习（RLVR）的扩展。在 Lambda 函数内部，需调用 Amazon Bedrock 中托管的任一模型。
**重要配置要求：**
| 配置 | 要求 | Details |
| --- | --- | --- |
| Amazon Bedrock 吞吐量 | 充足的配额 | 确保所使用的 Amazon Bedrock 模型吞吐量配额足以满足训练工作负载 |
| Lambda 超时 | 延长超时 | 将 Lambda 函数超时配置为最多 15 分钟。默认设置为 3 秒，不足以满足 Amazon Bedrock 模型的响应需求 |
| Lambda 并发 | 提高并发 | Lambda 在训练期间会被并行调用。提高并发以提供最大程度的可用吞吐量 |
| 配方配置 | 匹配 Lambda 设置 | 并发限制必须在配方中进行配置 |
## 创建与运行作业
**启动训练作业**
使用 SageMaker 训练作业笔记本模板：[https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook)
**实例要求**
容器同时支持全秩和 LoRA 训练：
+ **LoRA 训练**：2/4/6/8 个 p5.48xlarge 或 p5en.48xlarge 实例
+ **全秩训练**：2/4/6/8 个 p5.48xlarge 实例（必需）
## 监控训练
训练日志包含每一步的全面指标。主要指标类别：
**奖励指标**
+ `critic/rewards/mean`、`critic/rewards/max`、`critic/rewards/min`：奖励分布
+ `val-score/rewards/mean@1`：验证奖励
**模型行为**
+ `actor/entropy`：策略多样性（值越高表示探索性越强）
**训练健康度**
+ `actor/pg_loss`：策略梯度损失
+ `actor/pg_clipfrac`：裁剪更新频率
+ `actor/grad_norm`：梯度范数
**响应特征**
+ `prompt_length/mean`、`prompt_length/max`、`prompt_length/min`：输入词元统计
+ `response_length/mean`、`response_length/max`、`response_length/min`：输出词元统计
+ `response/aborted_ratio`：不完整生成率（0 表示全部完成）
**性能**
+ `perf/throughput`：训练吞吐量
+ `perf/time_per_step`：每步训练时间
+ `timing_per_token_ms/*`：每个词元的处理时间
**资源使用**
+ `perf/max_memory_allocated_gb`、`perf/max_memory_reserved_gb`：GPU 内存
+ `perf/cpu_memory_used_gb`：CPU 内存
## 使用经过微调的模型
训练完成后，最终模型检查点将保存到指定的输出位置。检查点路径可在以下位置获取：
+ 训练日志
+ 输出 Amazon S3 位置（由笔记本中的 `output_s3_uri` 定义）中的 `manifest.json` 文件
## 限制与最佳实践
**限制**
+ **Lambda 超时**：奖励函数须在 15 分钟内执行完毕（防止进程失控并控制成本）
+ **仅支持单轮对话**：不支持多轮对话
+ **数据要求**：需具备充足的多样性；在稀疏奖励场景下（正例占比 ＜5%）训练难度较高
+ **计算成本**：比监督式微调更昂贵
+ **无多模态数据**：仅支持文本数据类型
**最佳实践**
**从小规模起步**
+ 从 100 – 200 个样本开始
+ 验证奖励函数正确性
+ 根据结果逐步扩展
**训练前评测**
+ 在 RFT 之前测试基线模型性能
+ 如果奖励始终为 0%，建议先通过 SFT 训练构建基础能力
+ 若奖励占比 ＞95%，则可能无需进行 RFT
**监控训练**
+ 跟踪平均奖励分数和分布
+ 注意过拟合（练奖励上升，而验证奖励下降）
+ 留意异常模式：
+ 奖励在 0.15 以下趋于平稳
+ 奖励方差随时间逐步增大
+ 验证性能下降
**优化奖励函数**
+ 在几秒钟内执行完毕（而非几分钟）
+ 尽量减少外部 API 调用
+ 使用高效算法
+ 实现完善的错误处理机制
+ 充分利用 Lambda 的并行扩展能力
**迭代策略**
如果奖励没有提升：
+ 调整奖励函数设计
+ 提升数据集多样性
+ 添加更多代表性样本
+ 确保奖励信号清晰一致
## 高级能力：Nova Forge
对于需要突破标准 RFT 限制的高级能力的用户，Nova Forge 作为付费订阅服务提供，包括：
+ 多轮对话支持
+ 执行时间超过 15 分钟的奖励函数
+ 额外的算法和调优选项
+ 自定义训练配方修改
+ 最先进的人工智能技术
Nova Forge 在 SageMaker HyperPod 上运行，旨在支持企业客户构建自己的前沿模型。
## 实用命令与技巧
您可使用一系列[可观测性脚本](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/SageMakerUilts/SageMakerJobsMonitoring)，帮助监控训练作业的状态和进度。
可用脚本包括：
+ 为训练作业状态更新启用电子邮件通知
+ 根据作业配置获取训练时间估算
+ 获取进行中作业的预期训练时间近似值
**安装**
**注意**
在使用以下任何脚本之前，请务必刷新 AWS 凭证。
```
pip install boto3
git clone https://github.com/aws-samples/amazon-nova-samples.git
cd amazon-nova-samples/customization/SageMakerUilts/SageMakerJobsMonitoring/
```
**基本用法**
```
# Enabling email notifications for training job status updates
python enable_sagemaker_job_notifs.py --email test@amazon.com test2@gmail.com --region us-east-1 --platform SMTJ
Creating resources........
Please check your email for a subscription confirmation email, and click 'Confirm subscription' to start receiving job status email notifications!
You'll receive the confirmation email within a few minutes.
```
```
# Obtaining training time estimates based on job configurations
python get_training_time_estimate.py
```
```
# Obtaining approximations for how long training is expected to take for in-progress jobs
python get-training-job-progress.py --region us-east-1 --job-name my-training-job --num-dataset-samples 1000
```
有关更多详细信息和示例，请参阅[此处](https://github.com/aws-samples/amazon-nova-samples/blob/main/customization/SageMakerUilts/SageMakerJobsMonitoring/README.md)。
# 监控迭代进度
您可以通过 MLflow 跟踪指标。
## Nova 自定义 – 为 SageMaker HyperPod 配置 MLflow
要让 SageMaker HyperPod 环境将指标输出到 MLflow，需要完成一些额外配置。
1. 打开 Amazon SageMaker AI
1. 选择 SageMaker Studio
1. 如果已创建配置文件，选择“打开 Studio”。
1. 如果未创建配置文件，选择“创建 SageMaker 域”进行创建
1. 选择 MLflow。如果未创建任何 MLflow 应用程序，请选择“创建 MLflow 应用程序”
1. 在 MLflow 应用程序上点击复制/粘贴按钮或“查看详细信息”菜单项，获取 ARN。提交训练作业时需要用到该 ARN。
![\[MLflow 应用程序上的“查看详细信息”按钮，显示了 ARN。\]](http://docs.aws.amazon.com/zh_cn/nova/latest/nova2-userguide/images/how-it-works.png)
1. 在 HyperPod 集群的执行角色中，添加以下策略。这将允许 HyperPod 集群调用 MLflow API 来发布指标。
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sagemaker-mlflow:*",
"Resource": [
"arn:aws:sagemaker:us-east-1:372836560492:mlflow-app/*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:ListMlflowTrackingServers",
"sagemaker:CallMlflowAppApi"
],
"Resource": "*"
}
]
}
```
### 通过 CLI 提交作业
需指定 4 个新增的覆盖参数，可在命令行中指定，也可在 yaml 配方文件中配置。
1. `mlflow_tracking_uri`：MLflow 应用程序的 ARN
1. `mlflow_experiment_name`：本次实验运行的名称
1. `mlflow_experiment_name`：指标在 MLflow 中存储对应的实验名称
1. `mlflow_run_name`：本实验的名称
命令行
```
--override-parameters '{"recipes.run.mlflow_tracking_uri": "arn:aws:sagemaker:us-east-1:925548216816:mlflow-app/app-B6XOUNCHQM4W", "recipes.run.mlflow_experiment_name": "myuser-sft-lora-exp1", "recipes.run.mlflow_run_name": "myuser-sft-lora-exp1-202512181940"}'
```
yaml：
```
## Run config
run:
mlflow_tracking_uri: "arn:aws:sagemaker:us-east-1:925548216816:mlflow-app/app-B6XOUNCHQM4W"
mlflow_experiment_name: "myuser-sft-lora-exp1"
mlflow_run_name: "myuser-sft-lora-exp1-202512181940"
```
### 通过 SageMaker Studio UI 提交作业
MLflow 集成已内置到 SageMaker Studio UI 中。提交训练作业时，只需指明要使用的 MLflow 应用程序实例。
1. 在 SageMaker Studio 中，依次进入：“模型”>“Nova 2.0 Lite”>“自定义”>“通过 UI 自定义”。
1. 展开“高级配置”部分
1. 选择用于接收训练指标的 MLflow 应用程序。您还可以在此设置实验名称和实验运行名称。
![\[MLflow 应用程序。\]](http://docs.aws.amazon.com/zh_cn/nova/latest/nova2-userguide/images/MLFlow-App.png)
### 通过 AWS AWS CLI提交作业
如果您使用 AWSAWS CLI，则必须创建一个 MLflow 应用程序，并将其作为输入传递给训练作业 API 请求。
```
mlflow_app_name=""
role_arn=""
bucket_name=""
region=""
mlflow_app_arn=$(aws sagemaker create-mlflow-app \
--name $mlflow_app_name \
--artifact-store-uri "s3://$bucket_name" \
--role-arn $role_arn \
--region $region)
```
## 创建 MLflow 应用程序
**使用 Studio UI**：如果您通过 Studio UI 创建训练作业，系统会自动创建默认 MLflow 应用程序，并在“高级选项”下默认选择该应用程序。
**使用 CLI**：如果您使用 CLI，则必须创建一个 MLflow 应用程序，并将其作为输入传递给训练作业 API 请求。
```
mlflow_app_name=""
role_arn=""
bucket_name=""
region=""
mlflow_app_arn=$(aws sagemaker create-mlflow-app \
--name $mlflow_app_name \
--artifact-store-uri "s3://$bucket_name" \
--role-arn $role_arn \
--region $region)
```
## 访问 MLflow 应用程序
**使用 CLI**：创建预签名 URL 以访问 MLflow 应用程序 UI：
```
aws sagemaker create-presigned-mlflow-app-url \
--arn $mlflow_app_arn \
--region $region \
--output text
```
**使用 Studio UI**：Studio UI 会展示存储在 MLflow 中的关键指标，并提供指向 MLflow 应用程序 UI 的链接。
## 要跟踪的关键指标
通过迭代监控以下指标，以评测模型优化效果并跟踪作业进度：
**针对 SFT**
+ 训练损失曲线
+ 已处理样本数量及处理耗时
+ 预留测试集上的性能准确率
+ 格式合规性（如有效 JSON 输出率）
+ 领域专属评估数据上的困惑度
**针对 RFT**
+ 训练过程中的平均奖励分数
+ 奖励分布（高奖励响应占比）
+ 验证奖励趋势（关注过拟合情况）
+ 任务专属成功率（如代码执行通过率、数学题准确率）
**一般性问题**
+ 迭代间基准性能变化
+ 代表性样本的人工评估分数
+ 生产环境指标（若采用迭代式部署）
## 停止迭代的判定条件
满足以下任一情况即可停止迭代：
+ **性能趋于平稳**：继续训练无法显著提升目标指标
+ **切换训练技术有效**：若某一技术效果趋于平稳，可尝试切换（如 SFT → RFT → SFT）以突破性能瓶颈
+ **达到目标指标**：已满足预设的成功标准
+ **检测到性能退化**：新迭代导致模型效果下降（参见下文回滚流程）
有关详细的评估流程，请参阅**评估**部分。
# 评估经过 SageMaker AI 训练的模型
评估过程旨在根据基准测试或自定义数据集评测训练模型的性能。评估过程通常涉及以下步骤：创建指向训练模型的评估配方、指定评估数据集和指标、提交单独的评估作业，以及根据标准基准测试或自定义数据进行评估。评估过程将输出存储在您的 Amazon S3 存储桶中的性能指标。
**注意**
本主题中描述的评估过程是一个离线过程。该模型根据固定的基准测试进行测试，并提供预定义的答案，而非实时或者通过实时用户互动进行评测。对于实时评估，您可以在模型部署到 Amazon Bedrock 之后通过调用 [Amazon Bedrock](https://docs.aws.amazon.com//bedrock/latest/userguide/import-with-create-custom-model.html) 运行时 API 对模型进行测试。
**Topics**
+ [先决条件](#nova-model-evaluation-prerequisites)
+ [可用的基准测试任务](#nova-model-evaluation-benchmark)
+ [特定于评估的配置](#nova-model-evaluation-config)
+ [运行评估训练作业](#nova-model-evaluation-notebook)
+ [评测和分析评估结果](#nova-model-evaluation-assess)
+ [评估最佳实践和疑难解答](#nova-model-evaluation-best-practices)
+ [可用子任务](#nova-model-evaluation-subtasks)
+ [推理模型评测](nova-reasoning-model-evaluation.md)
+ [RFT 评测](nova-rft-evaluation.md)
+ [实现奖励函数](nova-implementing-reward-functions.md)
## 先决条件
在开始评估训练作业之前，请注意具备以下内容：
+ 一款经过 SageMaker AI 训练、您想要评估其性能的 Amazon Nova 模型。
+ 用于评估的基本 Amazon Nova 配方。有关更多信息，请参阅 [获取 Amazon Nova 配方](nova-model-recipes.md#nova-model-get-recipes)。
## 可用的基准测试任务
一个可用的示例代码包，用于演示如何使用适用于 Amazon Nova 的 SageMaker AI 模型评测特征计算基准评测指标。要获取代码包，请参阅 [sample-Nova-lighteval-custom-task](https://github.com/aws-samples/sample-Nova-lighteval-custom-task/)。
下面是支持的可用行业标准基准测试列表。您可以在 `eval_task` 参数中指定以下基准测试。
**可用的模型评测基准测试**
| 基准 | 模式 | 说明 | 指标 | Strategy | 可用子任务 |
| --- | --- | --- | --- | --- | --- |
| mmlu | 文本 | 多任务语言理解：考核 57 个科目的知识。 | 准确性 | zs\$1cot | 是 |
| mmlu\$1pro | 文本 | MMLU（专业子集），专注于法律、医学、会计和工程等专业领域。 | 准确性 | zs\$1cot | 否 |
| bbh | 文本 | 高级推理任务：一系列具有挑战性的问题，用于考核更高级别的认知和解决问题的能力。 | 准确性 | fs\$1cot | 是 |
| gpqa | 文本 | 一般物理问题解答：评测对物理概念和相关问题解决能力的理解情况。 | 准确性 | zs\$1cot | 否 |
| math | 文本 | 数学问题解决：衡量在代数、微积分及应用题等领域的数学推理能力。 | exact\$1match | zs\$1cot | 是 |
| strong\$1reject | 文本 | 质量控制任务：测试模型检测和拒绝不当、有害或不正确内容的能力。 | deflection | zs | 是 |
| ifeval | 文本 | 指令跟随评估：衡量模型遵循给定指令并按照规范完成任务的准确程度。 | 准确性 | zs | 否 |
| gen\$1qa | 多模态（图像） | 自定义数据集评估：让您可以提供自己的数据集进行基准测试，将模型输出与参考答案及 ROUGE 和 BLEU 等指标进行比较。`gen_qa` 支持基于 Amazon Nova Lite 或 Amazon Nova Pro 的模型进行图像推理。其也支持自定义指标 Lambda 函数。（若需进行 RFT 评估，请使用 RFT 评估配方） | 全部 | gen\$1qa | 否 |
| mmmu | 多模态 | 大规模多学科多模态理解（MMMU）：大学水平的基准测试，包括 30 个学科的选择题与开放式问答题。 | 准确性 | zs\$1cot | 是 |
| llm\$1judge | 文本 | LLM-as-a-Judge 偏好比较：使用 Nova Judge 模型来确定提示的成对响应之间的偏好（B 与 A 比较），计算 B 比 A 更受欢迎的概率。 | 全部 | judge | 否 |
| mm\$1llm\$1judge | 多模态（图像） | 该全新基准评测的运行方式与上述基于文本的 `llm_judge` 一致。唯一区别在于其支持图像推理。 | 全部 | judge | 否 |
| rubric\$1llm\$1judge | 文本 | Rubric Judge 是基于 Nova 2.0 Lite 构建的增强版 LLM-as-a-judge 评估模型。与仅提供偏好判定的[原始评判模型](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/)不同，Rubric Judge 可针对每个提示动态生成自定义评估准则，并在多个维度上给出细粒度评分。 | 全部 | judge | 否 |
| aime\$12024 | 文本 | AIME 2024：2024 年美国数学邀请赛（American Invitational Mathematics Examination），用于考查高阶数学推理与问题求解能力 | exact\$1match | zs\$1cot | 否 |
| calendar\$1scheduling | 文本 | Natural Plan：日程规划任务，用于评估跨日期、跨人员的会议安排等规划能力 | exact\$1match | fs | 否 |
| humaneval | 文本 | HumanEval：一个基准测试数据集，旨在评估大型语言模型的代码生成能力 | pass@1 | zs | 否 |
## 特定于评估的配置
以下是关于配方中关键组成部分的详细介绍，以及有关如何根据您的使用案例对其进行修改的指导。
### 了解和修改配方
**常规运行配置**
```
run:
name: eval_job_name
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
replicas: 1
data_s3_path: ""
mlflow_tracking_uri: ""
mlflow_experiment_name : ""
mlflow_run_name : ""
```
+ `name`：评估作业的描述性名称。
+ `model_type`：指定要使用的 Nova 模型变体。请勿手动修改此字段。选项包括：
+ amazon.nova-micro-v1:0:128k
+ amazon.nova-lite-v1:0:300k
+ amazon.nova-pro-v1:0:300k
+ amazon.nova-2-lite-v1:0:256k
+ `model_name_or_path`：基本模型的路径或训练后检查点的 S3 路径。选项包括：
+ nova-micro/prod
+ nova-lite/prod
+ nova-pro/prod
+ nova-lite-2/prod
+ 训练后检查点的 S3 路径（`s3:customer-escrow-111122223333-smtj-/`）
**注意**
**评估训练后模型**
要在 Nova SFT 训练作业之后评估训练后模型，请在成功运行训练作业后按照以下步骤操作。在训练日志的末尾，您将会看到“训练已完成”的日志消息。您还将在输出存储桶中找到一个包含检查点位置的 `manifest.json` 文件。此文件将位于输出 S3 位置的 `output.tar.gz` 文件中。要继续进行评估，请使用此检查点，将其设置为配方配置中 `run.model_name_or_path` 的值。
+ `replica`：用于分布式推理（跨多节点运行推理）的计算实例数量。设置 `replica` > 1 可启用多节点推理，加速评估过程。若同时指定 `instance_count` 和 `replica`，以 `instance_count` 为准。请注意，多副本仅适用于 SageMaker AI 训练作业。
+ `data_s3_path`：输入数据集 Amazon S3 路径。此字段为必填字段，但应始终留空。
+ `mlflow_tracking_uri`:（可选）MLflow 跟踪服务器地址（仅在 SMHP 下需要）
+ `mlflow_experiment_name`:（可选）实验名称，用于对相关的机器学习运行记录进行分组
+ `mlflow_run_name`:（可选）实验中某次特定训练运行的自定义名称
**评估配置**
```
evaluation:
task: mmlu
strategy: zs_cot
subtask: abstract_algebra
metric: accuracy
```
+ `task`：指定要使用的评估基准测试或任务。支持的任务包括：
+ `mmlu`
+ `mmlu_pro`
+ `bbh`
+ `gpqa`
+ `math`
+ `strong_reject`
+ `gen_qa`
+ `ifeval`
+ `mmmu`
+ `llm_judge`
+ `mm_llm_judge`
+ `rubric_llm_judge`
+ `aime_2024`
+ `calendar_scheduling`
+ `humaneval`
+ `strategy`：定义评估方法。
+ `zs_cot`：零样本思维链，该提示方法激励大型语言模型逐步进行推理，而不提供明确的示例。
+ `fs_cot`：少样本思维链，该方法会先提供一些逐步推理的示例，然后再要求模型解决新问题。
+ `zs`：零样本，该方法事先无需任何训练示例即可解决问题。
+ `gen_qa`：专为自带数据集而设的策略。
+ `judge`：专门用于 Nova LLM as judge 和 `mm_llm_judge` 的策略。
+ `subtask`：可选。评估任务的具体组成部分。有关可用子任务的完整列表，请参阅[可用子任务](#nova-model-evaluation-subtasks)。
+ 在“可用的基准测试任务”中查看支持的子任务。
+ 如果没有子任务基准测试，则应移除此字段。
+ `metric`：要使用的评估指标。
+ `accuracy`：正确答案的百分比。
+ `exact_match`：对于 math 基准测试，返回输入预测字符串与其引用完全匹配的速率。
+ `deflection`：对于强烈拒绝基准测试，返回基本模型的相对偏差和差异显著性指标。
+ `all`:
对于 `gen_qa`、自带数据集基准测试，返回以下指标：
+ `rouge1`：衡量生成的文本和参考文本之间的一元（单个词）重叠度。
+ `rouge2`：衡量生成的文本和参考文本之间的二元（两个连续的词）重叠度。
+ `rougeL`：衡量文本之间的最长公共子序列，匹配中可以存在间隙。
+ `exact_match`：二进制分数（0 或 1），用于指示生成的文本是否与参考文本逐个字符完全匹配。
+ `quasi_exact_match`：与精确匹配类似，但更加宽松，通常忽略大小写、标点符号和空格差异。
+ `f1_score`：精度和查全率之间的调和平均数，衡量预测答案和参考答案之间的词语重叠度。
+ `f1_score_quasi`：与 f1\$1score 类似，但匹配更为宽松，使用忽略细微差异的标准化文本比较。
+ `bleu`：衡量生成的文本和参考文本之间 n-gram 匹配的精确度，通常用于翻译评估。
对于 `llm_judge` 和 `mm_llm_judge`，自定义数据集基准，需返回以下指标：
+ `a_scores`：前向和反向评估传递中 `response_A` 的获胜次数。
+ `a_scores_stderr`：成对判断中 `response_A_scores` 的标准误差。
+ `b_scores`：衡量前向和反向评估传递中 `response_B` 的获胜次数。
+ `a_scores_stderr`：成对判断中 `response_B_scores` 的标准误差。
+ `ties`：`response_A` 和 `response_B` 被评估为相等的判断数量。
+ `ties_stderr`：成对判断中 `ties` 的标准误差。
+ `inference_error`：无法适当评估的判断数量。
+ `score`：基于 `response_B` 在前向和反向传递中的获胜次数得出的总分。
+ `score_stderr`：基于 `response_B` 在前向和反向传递中的获胜次数得出的总分。
+ `inference_error_stderr`：成对判断中总分的标准误差。
+ `winrate`：使用 Bradley-Terry 概率模型计算的 `response_B` 比 `response_A` 更受欢迎的概率。
+ `lower_rate`：自动采样预估胜率的下限（第 2.5 百分位）。
+ `upper_rate`：自动采样预估胜率的上限（第 97.5 百分位）。
**推理配置（可选）**
```
inference:
max_new_tokens: 2048
top_k: -1
top_p: 1.0
temperature: 0
top_logprobs: 10
reasoning_effort: null # options: low/high to enable reasoning or null to disable reasoning
```
+ `max_new_tokens`：要生成的最大词元数量。必须是整数。（不适用于 LLM Judge）
+ `top_k`：要考虑的最高概率词元的数量。必须是整数。
+ `top_p`：词元采样的累积概率阈值。必须是 1.0 到 0.0 之间的浮点数。
+ `temperature`：词元选择的随机性（数值越高代表随机性越高），保持为 0 以使结果具有确定性。浮点类型，最小值为 0。
+ `top_logprobs`：推理响应中需返回的最高对数概率数量。取值必须为 0 到 20 之间的整数。对数概率包含消息内容中返回的输出词元及其对应的对数概率值。
+ `reasoning_effort`：控制具备推理能力模型的推理行为。仅当 `model_type` 指定了具备推理能力的模型（当前为 `amazon.nova-2-lite-v1:0:256k`）时，才需设置 `reasoning_effort`。可用选项为 null（未设置时的默认值；表示禁用推理）、low 或 high。
### 对数概率输出格式
在推理设置中配置 `top_logprobs` 后，评估输出会在 parquet 文件中包含词元级别的对数概率。每个词元位置都会以字典形式，返回排名靠前的候选词元及其对数概率，结构如下：
```
{
"Ġint": {"logprob_value": -17.8125, "decoded_value": " int"},
"Ġthe": {"logprob_value": -2.345, "decoded_value": " the"}
}
```
每个词元条目包含：
+ `logprob_value`：词元的对数概率值
+ `decoded_value`：词元经解码后人类可读的字符串形式
原始分词器词元作为字典键以确保唯一性，`decoded_value` 则提供可读形式。
### 评估配方示例
Amazon Nova 提供四种不同类型的评估配方。所有配方均可在 [SageMaker HyperPod 配方 GitHub 存储库](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection)中找到。
**Topics**
#### 通用文本基准测试配方
这些配方让您能够通过一套全面的纯文本基准测试来评估 Amazon Nova 模型的基本功能。
配方格式：`xxx_general_text_benchmark_eval.yaml`。
#### 自带数据集基准测试配方
这些配方让您能够使用自己的数据集进行基准测试，并使用不同类型的指标将模型输出与参考答案进行对比。
配方格式：`xxx_ bring_your_own_dataset_eval.yaml`。
**自带数据集要求**
文件格式：
+ 包含评估示例的单个 `gen_qa.jsonl` 文件。文件名应为 `gen_qa.jsonl`。
+ 您必须将数据集上传到 SageMaker AI 训练作业可以访问的 S3 位置。
+ 该文件必须遵循常规问答数据集所需的架构格式。
架构格式要求：`.jsonl` 文件中的每一行都必须是包含以下字段的 JSON 对象。
+ 必填字段。
`query`：包含需要答案的问题或说明的字符串。
`response`: 包含预期模型输出的字符串。
+ 可选字段。
`system`：包含系统提示的字符串，用于在处理查询之前设置 AI 模型的行为、角色或个性。
`images`：对象数组，每个对象包含 data 属性（Base64 编码的图像字符串）。
`metadata`：字符串类型，与本条记录关联的元数据，用于标签分类。
**示例条目**
```
{
"system":"You are an English major with top marks in class who likes to give minimal word responses: ",
"query":"What is the symbol that ends the sentence as a question",
"response":"?"
}{
"system":"You are a pattern analysis specialist who provides succinct answers: ",
"query":"What is the next number in this series? 1, 2, 4, 8, 16, ?",
"response":"32"
}{
"system":"You have great attention to detail and follow instructions accurately: ",
"query":"Repeat only the last two words of the following: I ate a hamburger today and it was kind of dry",
"response":"of dry"
}{
"system": "Image inference: ",
"query": "What is the number in the image? Please just use one English word to answer.",
"response": "two",
"images": [
{
"data": "data:image/png;Base64,iVBORw0KGgoA ..."
}
]
}
```
要使用自定义数据集，请按以下必填字段修改评估配方，且不要更改现有配置：
```
evaluation:
task: gen_qa
strategy: gen_qa
metric: all
```
**限制**
+ 每次评估只支持一个 `.jsonl` 文件。
+ 该文件必须严格遵循定义的架构。
##### 自定义指标
您可以使用自定义指标，通过自定义预处理、后处理及指标能力，完全自定义模型评测流程。预处理可在将输入数据发送到推理服务器前对其进行处理；后处理支持自定义指标计算，并根据需求返回自定义指标。
请按如下步骤，通过自定义评估 SDK 接入自定义指标。
1. 若尚未操作，请先在 [AWS 账户 中创建 AWS Lambda 函数](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html)。
1. 从 [GitHub 存储库](https://github.com/aws/nova-custom-eval-sdk/releases)下载预构建的 `nova-custom-eval-layer.zip` 文件。您可通过这款开源的 Nova 自定义评估 SDK，验证自定义函数的输入/输出有效载荷，并提供统一接口，以集成到 Nova 训练过程中的自定义指标评估流程。
1. 执行以下命令上传自定义 Lambda 层：
```
aws lambda publish-layer-version \
--layer-name nova-custom-eval-layer \
--zip-file fileb://nova-custom-eval-layer.zip \
--compatible-runtimes python3.12 python3.11 python3.10 python3.9
```
1. 将该层作为自定义层添加到 Lambda 函数，同时需搭配必备的 AWS 层：`AWSLambdaPowertoolsPythonV3-python312-arm64`（为 `pydantic` 依赖项所需）。
1. 参考提供的示例修改 Lambda 代码（按需调整）。该示例代码可创建用于 Nova 自定义评估的 Lambda 函数，包含模型评测的预处理、后处理步骤。
```
from nova_custom_evaluation_sdk.processors.decorators import preprocess, postprocess
from nova_custom_evaluation_sdk.lambda_handler import build_lambda_handler
@preprocess
def preprocessor(event: dict, context) -> dict:
data = event.get('data', {})
return {
"statusCode": 200,
"body": {
"system": data.get("system"),
"prompt": data.get("prompt", ""),
"gold": data.get("gold", "")
}
}
@postprocess
def postprocessor(event: dict, context) -> dict:
# data is already validated and extracted from event
data = event.get('data', [])
inference_output = data.get('inference_output', '')
gold = data.get('gold', '')
metrics = []
inverted_accuracy = 0 if inference_output.lower() == gold.lower() else 1.0
metrics.append({
"metric": "inverted_accuracy_custom",
"value": accuracy
})
# Add more metrics here
return {
"statusCode": 200,
"body": metrics
}
# Build Lambda handler
lambda_handler = build_lambda_handler(
preprocessor=preprocessor,
postprocessor=postprocessor
)
```
1. 授予 Lambda 访问评估作业的权限。确保为评估作业指定的执行角色包含调用该 Lambda 函数的策略。以下为策略示例。
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LambdaAccess",
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"StringLike": {
"aws:PrincipalArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-ARN"
}
}
},
{
"Sid": "DenyNonAWSEventSourcesForLambda",
"Effect": "Deny",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"Null": {
"lambda:EventSourceToken": false
}
}
}
]
}
```
------
1. 核对 Lambda 有效载荷架构。下表列出了 Lambda 请求与响应的架构。您可通过 Nova 自定义评估 SDK 验证该架构。
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/nova/latest/nova2-userguide/nova-model-evaluation.html)
1. 修改配方文件。见下列。
```
processor:
lambda_arn: arn:aws:lambda:us-east-1:111122223333:function:name
lambda_type: "custom_metrics"
preprocessing:
enabled: true
postprocessing:
enabled: true
aggregation: average
```
+ `lambda-arn`：用于处理预处理和后处理逻辑的 Lambda 函数的 Amazon 资源名称（ARN）。
+ `lambda_type`：custom\$1metrics 或 rft。
+ `preprocessing`：是否启用自定义预处理操作。
+ `postprocessing`：是否启用自定义后处理操作。
+ `aggregation`：内置聚合函数（有效值：min、max、average、sum）。
**限制**
+ 自定义指标仅适用于文本输入数据集。
+ 不支持多模态输入数据集。
+ 预处理步骤不会处理元数据字段。
#### Nova LLM-as-a-Judge 基准测试配方
Nova LLM Judge 是一项模型评测特征，让您可以使用自定义数据集，将一个模型的响应质量与基准模型的响应质量进行比较。它接受包含提示、基准响应和挑战响应的数据集，然后使用 Nova Judge 模型基于 [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) 概率模型通过成对比较提供胜率指标。配方格式：`xxx_llm_judge_eval.yaml`。
**Nova LLM 数据集要求**
文件格式：
+ 包含评估示例的单个 `llm_judge.jsonl` 文件。文件名应为 `llm_judge.jsonl`。
+ 您必须将数据集上传到 SageMaker AI 训练作业可以访问的 S3 位置。
+ 该文件必须遵循 `llm_judge` 数据集所需的架构格式。
+ 输入数据集应确保所有记录的上下文长度小于 12k。
架构格式：`.jsonl` 文件中的每一行都必须是包含以下字段的 JSON 对象。
+ 必填字段。
`prompt`：包含生成响应提示的字符串。
`response_A`：包含基准响应的字符串。
`response_B`：包含与基准响应进行比较的替代响应的字符串。
示例条目
```
{
"prompt": "What is the most effective way to combat climate change?",
"response_A": "The most effective way to combat climate change is through a combination of transitioning to renewable energy sources and implementing strict carbon pricing policies. This creates economic incentives for businesses to reduce emissions while promoting clean energy adoption.",
"response_B": "We should focus on renewable energy. Solar and wind power are good. People should drive electric cars. Companies need to pollute less."
}
{
"prompt": "Explain how a computer's CPU works",
"response_A": "CPU is like brain of computer. It does math and makes computer work fast. Has lots of tiny parts inside.",
"response_B": "A CPU (Central Processing Unit) functions through a fetch-execute cycle, where instructions are retrieved from memory, decoded, and executed through its arithmetic logic unit (ALU). It coordinates with cache memory and registers to process data efficiently using binary operations."
}
{
"prompt": "How does photosynthesis work?",
"response_A": "Plants do photosynthesis to make food. They use sunlight and water. It happens in leaves.",
"response_B": "Photosynthesis is a complex biochemical process where plants convert light energy into chemical energy. They utilize chlorophyll to absorb sunlight, combining CO2 and water to produce glucose and oxygen through a series of chemical reactions in chloroplasts."
}
```
要使用您的自定义数据集，请按以下必填字段修改您的评估配方，且不要更改其中任何内容：
```
evaluation:
task: llm_judge
strategy: judge
metric: all
```
**限制**
+ 每次评估只支持一个 `.jsonl` 文件。
+ 该文件必须严格遵循定义的架构。
+ Nova Judge 模型对于 micro/lite/pro 规格是一样的。
+ 目前不支持自定义评估模型。
##### 使用 Nova LLM-as-a-judge，完成多模态（图像）基准测试配方
Nova LLM Judge 多模态（图像）版（简称 Nova MM\$1LLM Judge）是一项模型评测功能，支持使用自定义数据集，将目标模型的响应质量与基准模型的响应进行对比评估。该功能接受包含提示、基准响应和挑战响应的数据集，以及 Base64 编码字符串图像，然后使用 Nova Judge 模型基于 [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) 概率模型通过成对比较提供胜率指标。配方格式：`xxx_mm_llm_judge_eval.yaml`。
**Nova LLM 数据集要求**
文件格式：
+ 包含评估示例的单个 `mm_llm_judge.jsonl` 文件。文件名称必须严格为 `llm_judge.jsonl`。
+ 您必须将数据集上传到 SageMaker AI 训练作业可以访问的 S3 位置。
+ 该文件必须遵循 `mm_llm_judge` 数据集所需的架构格式。
+ 输入数据集应确保：排除 image 属性后，所有记录的上下文长度均小于 12k。
架构格式：`.jsonl` 文件中的每一行都必须是包含以下字段的 JSON 对象。
+ 必填字段。
`prompt`：包含生成响应提示的字符串。
`images`：对象数组，每个对象包含 data 属性（值为 Base64 编码的图像字符串）。
`response_A`：包含基准响应的字符串。
`response_B`：包含与基准响应进行比较的替代响应的字符串。
示例条目
为便于阅读，以下示例包含换行与缩进，但在实际数据集中，每条记录必须单独占一行。
```
{
"prompt": "What is in the image?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
}
],
"response_A": "a dog.",
"response_B": "a cat.",
}
{
"prompt": "How many animals are in each of the images?",
"images": [
{
"data": "data:image/jpeg;Base64,/9j/2wBDAAQDAwQDAwQEAwQFBAQFBgo..."
},
{
"data": "data:image/jpeg;Base64,/DKEafe3gihn..."
}
],
"response_A": "The first image contains one cat and the second image contains one dog",
"response_B": "The first image has one aminal and the second has one animal"
}
```
要使用您的自定义数据集，请按以下必填字段修改您的评估配方，且不要更改其中任何内容：
```
evaluation:
task: mm_llm_judge
strategy: judge
metric: all
```
**限制**
+ 每次评估只支持一个 `.jsonl` 文件。
+ 该文件必须严格遵循定义的架构。
+ Nova MM Judge 模型仅支持图像参考。
+ Nova MM Judge 模型在 Amazon Nova Micro、Amazon Nova Lite、Amazon Nova Pro 各规格中保持一致。
+ 目前不支持自定义评估模型。
+ 不支持 Amazon S3 图像 URI。
+ 输入数据集应确保：排除 image 属性后，所有记录的上下文长度均小于 12k。
#### 评测持续预训练（CPT）检查点
对持续预训练（CPT）模型的评测可能比经过监督式微调（SFT）的模型更具挑战性，因为 CPT 模型通常缺乏遵循指令的能力。CPT 模型不会遵循指令，而是作为补全模型运行，这意味着它们只会尝试延续输入词元序列所提供的模式。鉴于这一限制，典型的评测数据集可能无法正常工作，因为输入是“问答”格式，而模型不会回答问题，只会尝试沿着同一个问题继续生成。不过，通过以特定方式格式化数据集，以补全风格提示模型，即可了解模型的性能表现。
请按照以下步骤，了解如何使用 Nova Forge 评测工作流对持续预训练模型进行评测。
##### 数据集准备与格式化
评测 CPT 模型可以利用 Nova Forge 模型评测体验中已有的[自带数据集](#nova-model-evaluation-config-byo)工作流。不过，数据集中的查询必须格式化为纯粹的“补全”格式，因为 CPT 模型不会像 SFT 模型那样对标准的提问式提示做出响应。
另一个常见的限制是，仅经过 CPT 的模型通常无法生成 STOP 或序列结束词元，这意味着模型会持续生成词元，直到被强制停止（例如通过 max\$1new\$1tokens 参数）。鉴于这一限制，最佳实践是使用单词元响应（如单选题）来评测模型，确保模型不会在提示后继续生成不需要的垃圾输出。
例如，典型的评测数据集（如 MMLU、GPQA、MATH 等）可能会用如下问题提示模型：
```
Early settlements and high population density along coastlines and rivers are
best attributed to which of the following?
A: "Poor climate conditions"
B: "Limited forest cover"
C: "Cars"
D: "Access to trade routes"
(Expected answer is D.)
```
不过，由于 CPT 模型未经过指令遵循微调，因此无法正确回答该问题。因此，CPT 模型必须以补全风格进行提示，例如：
```
Early settlements and high population density along coastlines and rivers
are best attributed to which of the following?
A: Poor climate conditions
B: Limited forest cover
C: Cars
D: Access to trade routes
The correct answer to this question is option
(Expected answer is D.)
```
在推理后检查模型生成的输出对数概率，可获得有关模型是否正确处理输入并生成正确响应的详细信息。不能保证模型始终生成预期的确切响应（本例中为字母 D），但如果模型功能正常，该响应应该出现在对数概率中。
另一个非单选题的补全式提示示例：
```
The capital of France is
(Expected answer of Paris)
```
我们期望模型生成“巴黎”作为响应，或者在对数概率输出的某处看到对应于“巴黎”的词元。
##### 数据集格式化
CPT 评测利用现有的[自带数据集](#nova-model-evaluation-config-byo)工作流。数据必须以“查询-响应”格式进行格式化，存放在由换行分隔的 JSONL 文件中。
包含 4 条数据的数据集示例：
```
{"query": "The capital of France is", "response": "Paris"}
{"query": "2 + 2 =", "response": "4"}
{"query": "The mitochondria is the powerhouse of the", "response": "cell"}
{"query": "What is the largest planet?\nA: Mars\nB: Jupiter\nC: Saturn\nD: Earth\nAnswer:", "response": "B"}
```
每行必须包含：
+ `query`：用于补全的提示文本
+ `response`：预期的补全（真实值）
模型将接收原始文本输入，不带聊天格式。CPT 模型通常尚未针对特殊词元进行训练，无法正确适配聊天模板。因此在对模型进行提示时，仅会将查询中提供的字符串发送给模型（系统会自动在其前方添加一个 `[BOS]` 词元）。
##### 配方配置
以下是配置用于评测 CPT 模型的配方示例：
```
run:
name: cpt_eval_job
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: s3://bucket/path/to/cpt-checkpoint/
evaluation:
task: gen_qa # Required for CPT - bring your own dataset
strategy: gen_qa
metric: all # Returns rouge1, rouge2, rougeL, exact_match, f1_score, bleu
inference:
checkpoint_is_instruction_tuned: "false" # Required for CPT checkpoints
top_logprobs: 5 # Change to desired amount of logprobs to calculate
max_new_tokens: 1 # Keep low for completion tasks
temperature: 0.0
```
CPT 评测的关键调整：
+ `checkpoint_is_instruction_tuned: "false"`
这是一个新增参数，专门用于支持对 CPT 检查点进行评测。将 checkpoint\$1is\$1instruction\$1tuned 设置为 false 将**禁用**默认的 Amazon Nova 聊天模板（该模板通常会包装输入提示）。
+ `top_logprobs: 5`
对数概率揭示了模型在可能的下一个词元上的置信度分布，帮助您评测模型在预训练期间是否学会了预期的补全内容。通常，如果模型按预期运行，我们应该看到预期的响应（例如“A”、“B”等）作为生成的输出词元或者对数概率中的一个词元。
+ `max_new_tokens: 1`
CPT 模型通常尚未经过相关训练，不会生成特殊的“停止”或“序列结束”词元以指示何时停止推理。这意味着模型通常会持续生成新词元，直至达到设定的最大词元长度，从而产生不必要的推理开销。通常，将 max\$1new\$1tokens 限制为 1 并采用可通过单次响应（如单选题）评测模型的提示，是最高效的提示方式。将 max\$1new\$1tokens 设置为 1，可确保不会生成额外的垃圾词元。
##### 关键参数
+ **checkpoint\$1is\$1instruction\$1tuned**：必须设置为 `"false"`（或设置为布尔值 `false`）以禁用聊天模板
+ **top\$1logprobs**：建议设为 5，用于观察模型在 CPT 过程中的学习状态
+ **task**：必须为 `gen_qa`，CPT 模型无法使用 MMLU、MATH 这类指令遵循评测基准
+ **strategy**：必须为 `gen_qa`
+ **max\$1new\$1tokens**：建议保持较低值（1 – 5），因为 CPT 模型专注于补全任务，而非开放生成
## 运行评估训练作业
使用以下示例笔记本启动训练作业。请参考下方的笔记本示例，运行评估训练作业。有关更多信息，请参阅[使用 SageMaker AI 估算器运行训练作业](https://docs.aws.amazon.com//sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry-estimator.html)。
### 参考表
在运行笔记本之前，请参阅以下参考表来选择映像 URI 和实例配置。
**选择映像 URI**
| 指南 | 映像 URI |
| --- | --- |
| 评估映像 URI | 708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest |
**选择实例类型和计数**
| 模型 | 作业类型 | 实例类型 | 推荐的实例计数 | 支持的实例计数 |
| --- | --- | --- | --- | --- |
| Amazon Nova Micro | 评估（SFT/DPO） | g5.12xlarge | 1 | 1–16 |
| Amazon Nova Lite | 评估（SFT/DPO） | g5.12xlarge | 1 | 1–16 |
| Amazon Nova Pro | 评估（SFT/DPO） | p5.48xlarge | 1 | 1–16 |
### 示例笔记本
以下示例笔记本演示了如何运行评估训练作业。
```
# install python SDK
# Do not use sagemaker v3, as sagemaker v3 introduced breaking changes
!pip install sagemaker==2.254.1
import os
import sagemaker,boto3
from sagemaker.inputs import TrainingInput
from sagemaker.pytorch import PyTorch
sagemaker_session = sagemaker.Session()
role = sagemaker.get_execution_role()
# Download recipe from https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/evaluation/nova to local
# Assume the file name be `recipe.yaml`
# Populate parameters
# input_s3_uri = "s3:///input/" # (Optional) Only used for multi-modal dataset or bring your own dataset s3 location
output_s3_uri= "s3:///output/" # Output data s3 location, a zip containing metrics json and tensorboard metrics files will be stored to this location
instance_type = "instance_type" # ml.g5.16xlarge as example
instance_count = 1 # The number of instances for inference (set instance_count > 1 for multi-node inference to accelerate evaluation)
job_name = "your job name"
recipe_path = "recipe path" # ./recipe.yaml as example
image_uri = "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest" # Do not change
output_kms_key = "" # optional, leave blank for Amazon managed encryption
# (Optional) To bring your own dataset and LLM judge for evaluation
# evalInput = TrainingInput(
# s3_data=input_s3_uri,
# distribution='FullyReplicated',
# s3_data_type='S3Prefix'
#)
estimator = PyTorch(
output_path=output_s3_uri,
base_job_name=job_name,
role=role,
instance_type=instance_type,
instance_count=instance_count,
training_recipe=recipe_path,
sagemaker_session=sagemaker_session,
image_uri=image_uri,
output_kms_key=output_kms_key
)
estimator.fit()
# If input dataset exist, pass in inputs
# estimator.fit(inputs={"train": evalInput})
```
## 评测和分析评估结果
成功完成评估作业后，您可以使用以下步骤评测和分析结果。
**要评测和分析结果，请执行以下步骤：**
1. 了解输出位置结构。结果以压缩文件的形式存储在您指定的 Amazon S3 输出位置：
```
s3://your-bucket/output/benchmark-name/
└── job_name/
└── output/
└── output.tar.gz
```
1. 从存储桶下载 `output.tar.gz` 文件。解压缩要显示的内容。
```
run_name/
├── eval_results/
| └── results_[timestamp].json
│ └── inference_output.jsonl (only present for gen_qa)
| └── details/
| └── model/
| └── /
| └──details__#_.parquet
└── tensorboard_results/
└── eval/
└── events.out.tfevents.[timestamp]
```
+ `results_[timestamp].json`：输出指标 JSON 文件
+ `details__#_.parquet`：推理输出文件（`strong_reject` 除外）
+ `events.out.tfevents.[timestamp]`：TensorBoard 输出文件
+ `inference_output.jsonl`：已清理推理输出文件（仅适用于 `gen_qa` 任务）
1. 在 TensorBoard 中查看结果。要可视化您的评估指标，请执行以下操作：
1. 将解压缩的文件夹上传至 S3 存储桶
1. 导航到 SageMaker AI TensorBoard
1. 选择您的“S3 文件夹”。
1. 添加 S3 文件夹路径
1. 等待同步完成
1. 分析推理输出。除 `llm_judge` 和 `strong_reject` 之外，所有评估任务在推理输出中都将包含以下用于分析的字段。
+ `full_prompt`：发送给模型用于评估任务的完整用户提示。
+ `gold`：包含数据集指定的正确答案的字段。
+ `metrics`：包含根据单个推理评估的指标的字段。需要聚合的值对于单个推理输出没有值。
+ `predictions`：包含模型针对给定提示的输出列表的字段。
+ `pred_logits`：该字段包含消息内容中返回的输出词元及其对应的对数概率值。
通过查看这些字段，您可以确定指标差异的原因并了解自定义模型的行为。
对于 `llm_judge`，推理输出文件针对每对评估会在指标字段下包含以下字段。
+ `forward_output`：按顺序评估时 Judge 的原始偏好（response\$1A、response\$1B）。
+ `backward_output`：按相反顺序进行评估时 Judge 的原始偏好（response\$1B、response\$1A）。
+ `Pairwise metrics`：按每对前向和反向评估计算的指标包括 `a_scores`、`b_scores`、`ties`、`inference-score` 和 `score`。
**注意**
诸如 `winrate` 的聚合指标仅在摘要结果文件中提供，不会针对每一判断都提供。
对于 `gen_qa`，`inference_output.jsonl` 文件针对每个 JSON 对象均包含以下字段：
+ prompt：提交给模型的最终提示
+ 推理：模型的原始推理输出
+ gold：来自输入数据集的目标响应
+ metadata：来自输入数据集的元数据字符串（如果提供）
## 评估最佳实践和疑难解答
### 最佳实践
下面列出了评估过程的一些最佳实践。
+ 按模型和基准测试类型整理输出路径。
+ 保持一致的命名约定以便于跟踪。
+ 将解压缩的结果保存在安全的位置。
+ 监控 TensorBoard 同步状态以成功加载数据。
### 问题排查
您可以使用 CloudWatch 日志组 `/aws/sagemaker/TrainingJobs` 来记录训练作业错误日志。
#### 引擎核心故障
**问题：**
如遇以下报错：
```
RuntimeError: Engine core initialization failed.
```
**原因：**
虽然这是一个可能由多种原因引发的一般性错误，但最常见原因是：您尝试加载的模型检查点与指定的模型类型（model\$1type）不匹配。例如，您想要评估一个微调后的 Nova 2.0 lite 模型检查点，但指定的模型类型却是 1.0 版本（如 `amazon.nova-micro-v1:0:128k`）
正确的映射示例：
```
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
```
**预防措施**：
提交评估作业前，务必核对 `model_name_or_path` 与 `model_type` 是否正确匹配。
## 可用子任务
下面列出了跨多个领域进行模型评测的可用子任务，包括 MMLU（大规模多任务语言理解）、BBH（高难度推理基准）、MATH（数学推理）和 MMMU（大规模多学科多模态理解）。这些子任务让您能够评测模型在特定功能和知识领域的表现。
**MMLU**
```
MMLU_SUBTASKS = [
"abstract_algebra",
"anatomy",
"astronomy",
"business_ethics",
"clinical_knowledge",
"college_biology",
"college_chemistry",
"college_computer_science",
"college_mathematics",
"college_medicine",
"college_physics",
"computer_security",
"conceptual_physics",
"econometrics",
"electrical_engineering",
"elementary_mathematics",
"formal_logic",
"global_facts",
"high_school_biology",
"high_school_chemistry",
"high_school_computer_science",
"high_school_european_history",
"high_school_geography",
"high_school_government_and_politics",
"high_school_macroeconomics",
"high_school_mathematics",
"high_school_microeconomics",
"high_school_physics",
"high_school_psychology",
"high_school_statistics",
"high_school_us_history",
"high_school_world_history",
"human_aging",
"human_sexuality",
"international_law",
"jurisprudence",
"logical_fallacies",
"machine_learning",
"management",
"marketing",
"medical_genetics",
"miscellaneous",
"moral_disputes",
"moral_scenarios",
"nutrition",
"philosophy",
"prehistory",
"professional_accounting",
"professional_law",
"professional_medicine",
"professional_psychology",
"public_relations",
"security_studies",
"sociology",
"us_foreign_policy",
"virology",
"world_religions"
]
```
**BBH**
```
BBH_SUBTASKS = [
"boolean_expressions",
"causal_judgement",
"date_understanding",
"disambiguation_qa",
"dyck_languages",
"formal_fallacies",
"geometric_shapes",
"hyperbaton",
"logical_deduction_five_objects",
"logical_deduction_seven_objects",
"logical_deduction_three_objects",
"movie_recommendation",
"multistep_arithmetic_two",
"navigate",
"object_counting",
"penguins_in_a_table",
"reasoning_about_colored_objects",
"ruin_names",
"salient_translation_error_detection",
"snarks",
"sports_understanding",
"temporal_sequences",
"tracking_shuffled_objects_five_objects",
"tracking_shuffled_objects_seven_objects",
"tracking_shuffled_objects_three_objects",
"web_of_lies",
"word_sorting"
]
```
**数学**
```
MATH_SUBTASKS = [
"algebra",
"counting_and_probability",
"geometry",
"intermediate_algebra",
"number_theory",
"prealgebra",
"precalculus",
```
**MMMU**
```
MATH_SUBTASKS = [
"Accounting",
"Agriculture",
"Architecture_and_Engineering",
"Art",
"Art_Theory",
"Basic_Medical_Science",
"Biology",
"Chemistry",
"Clinical_Medicine",
"Computer_Science",
"Design",
"Diagnostics_and_Laboratory_Medicine",
"Economics",
"Electronics",
"Energy_and_Power",
"Finance",
"Geography",
"History",
"Literature",
"Manage",
"Marketing",
"Materials",
"Math",
"Mechanical_Engineering",
"Music",
"Pharmacy",
"Physics",
"Psychology",
"Public_Health",
"Sociology",
```
您可通过多种评估方法与指标，对自定义 Nova 模型进行评估。
**Topics**
+ [先决条件](#nova-model-evaluation-prerequisites)
+ [可用的基准测试任务](#nova-model-evaluation-benchmark)
+ [特定于评估的配置](#nova-model-evaluation-config)
+ [运行评估训练作业](#nova-model-evaluation-notebook)
+ [评测和分析评估结果](#nova-model-evaluation-assess)
+ [评估最佳实践和疑难解答](#nova-model-evaluation-best-practices)
+ [可用子任务](#nova-model-evaluation-subtasks)
+ [推理模型评测](nova-reasoning-model-evaluation.md)
+ [RFT 评测](nova-rft-evaluation.md)
+ [实现奖励函数](nova-implementing-reward-functions.md)
# 推理模型评测
## 概述
推理模型支持功能可借助具备推理能力的 Nova 模型开展评估，这类模型会在生成最终响应前执行显式的内部推理。该功能通过 `reasoning_effort` 参数实现 API 级别的控制，可动态启用/禁用推理功能，有助于提升复杂分析类任务的响应质量。
**支持的模型**
+ amazon.nova-2-lite-v1:0:256k
## 配方配置
在配方的 `inference` 模块中添加 `reasoning_effort` 参数，即可启用推理功能：
```
run:
name: reasoning-eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Must be a reasoning-supported model
model_name_or_path: nova-lite-2/prod # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [MODIFIABLE] Leave empty for SageMaker Training job; optional for SageMaker HyperPod job
output_s3_path: "" # [MODIFIABLE] Output path for SageMaker HyperPod job (not compatible with SageMaker Training jobs)
evaluation:
task: mmlu # [MODIFIABLE] Evaluation task
strategy: zs_cot # [MODIFIABLE] Evaluation strategy
metric: accuracy # [MODIFIABLE] Metric calculation method
inference:
reasoning_effort: high # [MODIFIABLE] Enables reasoning mode; options: low/high or null to disable
max_new_tokens: 32768 # [MODIFIABLE] Maximum tokens to generate, recommended value when reasoning_effort set to high
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
## reasing\$1effort 参数使用说明
`reasoning_effort` 参数用于控制具备推理能力模型的推理行为。
### 先决条件
+ **模型兼容性**：仅当 `model_type` 指定了具备推理能力的模型（当前为 `amazon.nova-2-lite-v1:0:256k`）时，才需设置 `reasoning_effort`
+ **错误处理**：对不受支持的模型使用 `reasoning_effort` 将会失败，并返回 `ConfigValidationError: "Reasoning mode is enabled but model '{model_type}' does not support reasoning. Please use a reasoning-capable model or disable reasoning mode."` 错误
### 可用选项
| Option | 行为 | 词元限制 | 使用案例 |
| --- | --- | --- | --- |
| null（默认） | 禁用推理模式 | 不适用 | 无需推理开销的标准评估 |
| low | 启用推理并施加约束 | 内部推理占用 4000 词元 | 需要简洁推理的场景；兼顾速度与成本优化 |
| high | 启用推理且无约束 | 内部推理无词元上限 | 需要深度分析与分步推理的复杂问题 |
| 训练模型 | 可用选项 | 配置方法 |
| --- | --- | --- |
| 监督式微调（SFT） | 仅限 High 或 Off | 使用 reasoning\$1enabled: true（high）或 reasoning\$1enabled: false（off） |
| 强化微调（RFT） | Low、High 或 Off | 使用 reasoning\$1effort: low 或 reasoning\$1effort: high。省略字段以禁用。 |
| 评估 | Low、High 或 Off | 使用 reasoning\$1effort: low 或 reasoning\$1effort: high。设为 null 即可禁用。 |
### 何时启用推理
**满足以下场景时，建议使用推理模式（`low` 或 `high`）**
+ 复杂问题求解任务（数学、逻辑谜题、编程）
+ 需要中间推理过程的多步分析类问题
+ 详细推导或分步思考可提升准确率的任务
+ 优先保证响应质量而非速度的场景
**满足以下场景时，建议使用非推理模式（`null` 或不设置该参数）**
+ 简单问答或事实查询
+ 创意写作类任务
+ 对响应速度要求极高的场景
+ 需要排除推理开销的性能基准测试
+ 推理无法提升效果、需优化成本的场景
### 问题排查
**错误：“Reasoning mode is enabled but model does not support reasoning”**
**原因**：`reasoning_effort` 参数被设为非空值，但指定的 `model_type` 支持推理。
**解决方法：**
+ 确认模型类型为 `amazon.nova-2-lite-v1:0:256k`
+ 若使用其他模型，或切换为具备推理能力的模型，或从配方中移除 `reasoning_effort` 参数
# RFT 评测
## 什么是 RFT 评测？
RFT 评测支持您在强化学习微调的训练前、训练中及训练后，通过自定义奖励函数评测模型性能。与采用预定义指标的标准评测不同，RFT 评测支持通过 Lambda 函数自定义成功标准，并依据您的具体需求对模型输出进行评分。
## 为什么要使用 RFT 进行评测？
评测对于判断强化微调过程是否实现以下目标至关重要：
+ 提升模型与您特定使用案例及人类价值偏好的对齐程度
+ 维持或提升模型在核心任务上的能力
+ 避免产生非预期副作用，例如事实准确性下降、内容冗余度增加或其他任务性能退化
+ 满足由奖励函数定义的自定义成功标准
## 何时使用 RFT 评测
在以下场景中使用 RFT 评测：
+ RFT 训练之前：在评测数据集上建立基线指标
+ RFT 训练期间：使用中间检查点监控训练进度
+ RFT 训练之后：验证最终模型是否符合您的要求
+ 模型对比：采用一致的奖励标准对多个模型版本进行评测
**注意**
如需领域专属的自定义评估指标，请使用 RFT 评测。对于通用评测（准确率、困惑度、BLEU），请使用标准评测方法。
## 数据格式要求
### 输入数据结构
RFT 评测输入数据必须遵循 OpenAI 强化微调格式。每个样本都是一个 JSON 对象，其中包含：
+ `messages`：包含 `system` 和 `user` 角色的对话轮次数组
+ `reference_answer`：奖励函数用于评分的预期输出或真实值数据
### 数据格式示例
```
{
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Solve for x. Return only JSON like {\"x\": }. Equation: 2x + 5 = 13"
}
]
}
],
"reference_answer": {
"x": 4
}
}
```
### 目前的局限性
+ 纯文本模式：不支持多模态输入（图像、音频、视频）
+ 单轮对话：仅支持单条用户消息（不支持多轮对话）
+ JSON 格式：输入数据必须为 JSONL 格式（每行一个 JSON 对象）
+ 模型输出：根据指定模型生成的补全进行评测
## 准备评测配方
### 示例笔记本
有关完整示例，请参阅[评测笔记本](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook)。
### 示例配方配置
```
run:
name: nova-lite-rft-eval-job
model_type: amazon.nova-lite-v1:0:300k
model_name_or_path: s3://escrow_bucket/model_location # [MODIFIABLE] S3 path to your model or model identifier
replicas: 1 # [MODIFIABLE] For SageMaker Training jobs only; fixed for HyperPod jobs
data_s3_path: "" # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs and use TrainingInput in sagemaker python SDK
output_s3_path: "" # [REQUIRED] Output artifact S3 path for evaluation results
evaluation:
task: rft_eval # [FIXED] Do not modify
strategy: rft_eval # [FIXED] Do not modify
metric: all # [FIXED] Do not modify
# Inference Configuration
inference:
max_new_tokens: 8192 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
top_logprobs: 0 # [MODIFIABLE] Set between 1-20 to enable logprobs output
# =============================================================================
# Bring Your Own Reinforcement Learning Environment
# =============================================================================
rl_env:
reward_lambda_arn: arn:aws:lambda:::function:
```
## 预设奖励函数
两个预设的奖励函数（`prime_code` 和 `prime_math`）可用作 Lambda 层，以便与 RFT Lambda 函数集成。
### 概述
这些预设函数提供开箱即用的评测能力，适用于：
+ `prime_code`：代码生成和正确性评测
+ `prime_math`：数学推理和问题求解评测
### 快速设置
1. 从 [nova-custom-eval-sdk 版本](https://github.com/aws/nova-custom-eval-sdk/releases)页面下载 Lambda 层。
1. 使用 AWS 命令行界面（AWS CLI）发布 Lambda 层：
```
aws lambda publish-layer-version \
--layer-name preset-function-layer \
--description "Preset reward function layer with dependencies" \
--zip-file fileb://universal_reward_layer.zip \
--compatible-runtimes python3.9 python3.10 python3.11 python3.12 \
--compatible-architectures x86_64 arm64
```
1. 在 AWS 管理控制台中将该层添加到 Lambda 函数（从自定义层中选择 preset-function-layer，并添加 AWSSDKPandas-Python312 以获取 numpy 依赖项）。
1. 在 Lambda 代码中导入并使用：
```
from prime_code import compute_score # For code evaluation
from prime_math import compute_score # For math evaluation
```
### prime\$1code 函数
通过针对测试用例执行代码并衡量正确性来评测 Python 代码生成任务。
**输入数据集格式示例**
```
{"messages":[{"role":"user","content":"Write a function that returns the sum of two numbers."}],"reference_answer":{"inputs":["3\n5","10\n-2","0\n0"],"outputs":["8","8","0"]}}
{"messages":[{"role":"user","content":"Write a function to check if a number is even."}],"reference_answer":{"inputs":["4","7","0","-2"],"outputs":["True","False","True","True"]}}
```
**主要特征**
+ 从 Markdown 代码块中自动提取代码
+ 函数检测与基于调用的测试
+ 带超时保护的测试用例执行
+ 语法验证与编译检查
+ 包含回溯信息的详细错误报告
### prime\$1math 函数
依托符号计算能力，评测模型的数学推理与问题求解水平。
**输入格式**
```
{"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"}
```
**主要特征**
+ 使用 SymPy 进行符号计算评测
+ 支持多种答案格式（LaTeX、纯文本、符号）
+ 数学等价性检查
+ 表达式归一化与化简
### 数据格式要求
**评测代码**
+ 输入：函数参数数组（类型正确：整数、字符串等）
+ 输出：预期返回值数组（类型正确：布尔值、数字等）
+ 代码：必须使用 Python 编写，并包含清晰的函数定义
**数学评测**
+ 参考答案：数学表达式或数值
+ 响应：可为 LaTeX、纯文本或符号表达式
+ 等效：通过符号方式检查，而不仅仅是字符串匹配
### 最佳实践
+ 在测试用例中使用正确的数据类型（整数与字符串、布尔值与 True）
+ 在代码问题中提供清晰的函数签名
+ 在测试输入中包括边缘情况（零、负数、空输入）
+ 在参考答案中统一设置数学表达式的格式
+ 在部署前使用样本数据测试奖励函数
### 错误处理
这两个函数都包含针对以下情况的强大错误处理能力：
+ 生成的代码中存在编译错误
+ 执行过程中出现运行时异常
+ 输入数据格式错误
+ 超时场景无限循环
+ 数学表达式无效
## 创建奖励函数
### Lambda ARN 要求
Lambda ARN 必须采用以下格式：
```
"arn:aws:lambda:*:*:function:*SageMaker*"
```
如果 Lambda 不遵循此命名方案，作业将失败并显示以下错误：
```
[ERROR] Unexpected error: lambda_arn must contain one of: ['SageMaker', 'sagemaker', 'Sagemaker'] when running on SMHP platform (Key: lambda_arn)
```
### Lambda 请求格式
Lambda 函数接收以下格式的数据：
```
[
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Do you have a dedicated security team?"
}
]
},
{
"role": "nova_assistant",
"content": [
{
"type": "text",
"text": "As an AI developed by Company, I don't have a dedicated security team..."
}
]
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
]
```
**注意**
消息结构包含嵌套的 `content` 数组，与输入数据格式相匹配。角色为 `nova_assistant` 的最后一条消息包含模型生成的响应。
### Lambda 响应格式
Lambda 函数必须按以下格式返回数据：
```
[
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
]
```
**响应字段**
+ `id`：必须与输入样本 ID 匹配
+ `aggregate_reward_score`：总体得分（通常为 0.0 到 1.0）
+ `metrics_list`：各项指标组成的数组，包含以下字段：
+ `name`：指标标识符（例如 accuracy、fluency）
+ `value`：指标得分（通常为 0.0 到 1.0）
+ `type`：Metric（用于报告）或 Reward（用于训练）
## IAM 权限
### 所需的权限
SageMaker 执行角色必须具备调用 Lambda 函数的权限。将此策略添加到 SageMaker 执行角色：
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
### Lambda 执行角色
Lambda 函数的执行角色需要基本的 Lambda 执行权限：
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
如果 Lambda 函数访问其他 AWS 服务（例如用于参考数据的 S3、用于日志记录的 DynamoDB），请将这些权限添加到 Lambda 执行角色。
## 执行评测作业
1. **准备数据** – 根据数据格式要求格式化评测数据，并将 JSONL 文件上传到 S3：`s3://your-bucket/eval-data/eval_data.jsonl`
1. **配置配方** – 使用您的配置更新示例配方：
+ 将 `model_name_or_path` 设置为模型路径
+ 将 `lambda_arn` 设置为奖励函数 ARN
+ 将 `output_s3_path` 设置为目标输出位置
+ 根据需要调整 `inference` 参数
将配方另存为 `rft_eval_recipe.yaml`
1. **运行评测** – 使用提供的笔记本执行评测工作：[评测笔记本](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook)
1. **监控进度** – 通过以下方式监控评测作业：
+ SageMaker 控制台：检查作业状态与日志
+ CloudWatch Logs：查看详细执行日志
+ Lambda 日志：调试奖励函数相关问题
## 了解评测结果
### 输出格式
评测作业会以 JSONL 格式将结果输出到指定的 S3 位置。每行包含一个样本的评测结果：
```
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
```
**注意**
RFT 评测作业输出格式与 Lambda 响应格式完全一致。评测服务会原样透传 Lambda 函数的响应，确保奖励计算结果与最终输出保持一致。
### 解析结果
**奖励总分**
+ 取值范围：通常为 0.0（最差）到 1.0（最佳），具体取决于实现逻辑
+ 用途：以单一数值概括整体性能
+ 应用场景：模型对比、跟踪训练过程中的效果提升
**各项指标**
+ 指标类型：用于分析的参考性指标
+ 奖励类型：RFT 训练过程中使用的指标
+ 结果解读：数值越高通常表示性能越好（除非设计了反向指标）
### 性能基准
何种表现为“良好”取决于实际使用案例：
| 分数区间 | 评估结果 | 处理建议 |
| --- | --- | --- |
| 0.8 – 1.0 | 优秀 | 模型可直接部署 |
| 0.6 – 0.8 | 良好 | 可进行小幅优化 |
| 0.4 – 0.6 | 一般 | 需大幅优化提升 |
| 0.0 – 0.4 | 较差 | 检查训练数据和奖励函数 |
**重要**
以上仅为通用准则。请根据业务需求、基线模型性能、领域特定约束以及进一步训练的成本效益分析，自行定义阈值。
## 问题排查
### 常见问题
| 问题 | 原因 | 解决方案 |
| --- | --- | --- |
| Lambda 超时 | 奖励计算复杂 | 延长 Lambda 超时时间或优化函数逻辑 |
| 权限被拒绝 | 缺少 IAM 权限 | 验证 SageMaker 角色是否可调用 Lambda |
| 评分不一致 | 非确定性奖励函数 | 使用固定种子或确定性逻辑 |
| 结果缺失 | Lambda 错误未被捕获 | 在 Lambda 中添加完善的错误处理机制 |
### 调试检查清单
+ 验证输入数据格式是否正确（带有嵌套的内容数组）
+ 确认 Lambda ARN 正确且函数已部署
+ 检查 SageMaker → Lambda 调用的 IAM 权限
+ 查看 CloudWatch 日志中的 Lambda 错误
+ 验证 Lambda 响应符合预期格式
## 最佳实践
+ 从简入手：先实现基础奖励函数，再逐步迭代优化
+ 单独测试 Lambda：全面评测前先使用 Lambda 测试事件
+ 小规模数据集验证：完整数据集评测前，先对数据子集执行评测
+ 版本控制：同步追踪奖励函数与模型版本
+ 成本监控：Lambda 调用次数与计算时长会影响成本
+ 全面日志记录：在 Lambda 中使用打印语句便于调试
+ 合理设置超时：在执行时长与成本之间取得平衡
+ 指标文档化：明确定义各项指标的衡量标准
## 后续步骤
完成 RFT 评测后：
+ 如果结果令人满意：将模型部署到生产环境
+ 如果需要改进：
+ 调整奖励函数
+ 收集更多训练数据
+ 修改训练超参数
+ 运行额外的 RFT 训练迭代
+ 持续监控：定期使用新数据重新评测
# 实现奖励函数
## 概述
奖励函数（也称为评分器或打分器）是评测模型响应并为训练提供反馈信号的核心组件。其必须作为 Lambda 函数实现，接受模型响应并返回奖励分数。
## 接口规范
奖励函数必须按以下格式接收与返回数据：
**训练样本输入示例**
```
{
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**奖励 Lambda 的有效载荷示例**
容器在将数据发送到 Lambda 函数之前会自动进行转换，具体方式如下：
1. 为每个提示生成模型响应
1. 将 assistant 轮次（生成的响应）追加到 messages 数组中
1. 添加唯一的 `id` 字段用于跟踪
Lambda 函数将接收此转换格式的数据：
```
{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don not have a dedicated security team..."
}
],
# Following section will be same as your training dataset sample
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**奖励 Lambda 约定**
```
def lambda_handler(event, context):
return lambda_grader(event)
def lambda_grader(samples: list[dict]) -> list[dict]:
"""
Args:
samples: List of dictionaries in OpenAI format
Example input:
{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Company, I don nott have a dedicated security team..."
}
],
# This section will be same as your training dataset
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
Returns:
List of dictionaries with reward scores:
{
"id": str, # Same id as input sample
"aggregate_reward_score": float, # Overall score for the sample
"metrics_list": [ # OPTIONAL: Component scores
{
"name": str, # Name of the component score
"value": float, # Value of the component score
"type": str # "Reward" or "Metric"
}
]
}
"""
```
## 输入和输出字段
### 输入字段
| 字段 | 说明 | 附加说明 |
| --- | --- | --- |
| id | 样本的唯一标识符 | 在输出中原样返回。字符串格式 |
| 消息 | OpenAI 格式的有序聊天记录 | 消息对象数组 |
| messages[].role | 消息发送方 | 常用值：user、assistant、system |
| messages[].content | 消息文本内容 | 纯字符串 |
| \$1\$1metadata | 用于辅助评分的自定义信息 | 对象类型；由训练数据传入的可选字段 |
### 输出字段
| 字段 | 说明 | 附加说明 |
| --- | --- | --- |
| id | 与输入样本一致的标识符 | 必须与输入匹配 |
| aggregate\$1reward\$1score | 样本综合分数 | 浮点数（如 0.0 – 1.0 或任务自定义区间） |
| metrics\$1list | 构成综合评分的各单项评分 | 指标对象数组 |
## 技术约束
+ **超时限制**：每次 Lambda 调用最长执行时间为 15 分钟
+ **并发能力**：必须能够处理 `rollout_worker_replicas * 64` 个并发请求
+ **可靠性**：必须实现完善的错误处理机制，并稳定返回有效评分
+ **性能**：优化执行速度（秒级而非分钟级），保障训练高效运行
**最佳实践**
+ 尽量减少外部 API 调用
+ 使用高效的算法与数据结构
+ 为瞬时故障实现重试逻辑
+ 缓存可重复使用的计算结果
+ 训练前充分测试，确保执行无异常
## 使用自定义奖励函数
当存在针对特定任务的评测标准时，可实现自定义奖励函数：
+ **定义评测标准**：明确在当前任务中优质响应的判定依据
+ **实现 Lambda 函数**：按照接口规范创建 Lambda 函数
+ **本地测试**：验证函数对样本输入能返回正确评分
+ **部署到 AWS**：部署 Lambda 并记录其 ARN
+ **配置配方**：将 Lambda ARN 填入配方的 `reward_lambda_arn` 字段
+ **小规模数据集测试**： 使用少量数据运行 RFT，验证集成效果
## IAM 权限
### 所需的权限
SageMaker 执行角色必须具备调用 Lambda 函数的权限。将此策略添加到 SageMaker 执行角色：
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
### Lambda 执行角色
Lambda 函数的执行角色需要基本的 Lambda 执行权限：
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
其他权限：如果 Lambda 函数访问其他 AWS 服务（例如用于参考数据的 S3、用于日志记录的 DynamoDB），请将这些权限添加到 Lambda 执行角色。
## 示例：LLM-as-a-judge 奖励函数
此示例演示了如何使用 Amazon Bedrock 模型作为评判工具，通过将模型响应与参考答案进行比较来评测模型响应。此 Lambda 模板为用户提供框架，支持调用 Amazon Bedrock 发起推理请求，以完成评判评测处理。此 Lambda 函数与其他奖励函数采用一致的输入输出约定。
### 实施
此 Lambda 函数采用两阶段评测流程：`lambda_handler` 模块从输入样本中提取模型响应与参考答案，随后 `lambda_graded` 函数调用 Amazon Bedrock 对二者的语义相似度进行评分。该实现具备完善的错误处理机制，可对瞬时故障自动重试，并支持多种灵活的参考答案格式（字符串格式与结构化字典格式）。
**实现细节：**
+ **重试逻辑**：针对限流异常实现指数回退（1 秒、2 秒、4 秒），以应对 Bedrock API 速率节流
+ **错误处理**：评测失败时返回 0.0 分，而非抛出异常
+ **确定性评分**：使用 temperature=0.0 确保多次评测结果一致
+ **灵活参考格式**：自动支持字符串与字典两种格式的参考答案
+ **分数裁剪**：确保所有分数落在有效的 [0.0, 1.0] 区间内
+ **模型无关**：更改 JUDGE\$1MODEL\$1ID 即可使用任何 Amazon Bedrock 模型（Nova、Llama、Mistral 等）
```
"""
LLM Judge Lambda POC - Working implementation using Amazon Bedrock
"""
import json
import time
import boto3
bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1')
JUDGE_MODEL_ID = "anthropic.claude-3-5-sonnet-20240620-v1:0"
SYSTEM_PROMPT = "You must output ONLY a number between 0.0 and 1.0. No explanations, no text, just the number."
JUDGE_PROMPT_TEMPLATE = """Compare the following two responses and rate how similar they are on a scale of 0.0 to 1.0, where:
- 1.0 means the responses are semantically equivalent (same meaning, even if worded differently)
- 0.5 means the responses are partially similar
- 0.0 means the responses are completely different or contradictory
Response A: {response_a}
Response B: {response_b}
Output ONLY a number between 0.0 and 1.0. No explanations."""
def lambda_graded(response_a: str, response_b: str, max_retries: int = 3) -> float:
"""Call Bedrock to compare responses and return similarity score."""
prompt = JUDGE_PROMPT_TEMPLATE.format(response_a=response_a, response_b=response_b)
for attempt in range(max_retries):
try:
response = bedrock_runtime.converse(
modelId=JUDGE_MODEL_ID,
messages=[{"role": "user", "content": [{"text": prompt}]}],
system=[{"text": SYSTEM_PROMPT}],
inferenceConfig={"temperature": 0.0, "maxTokens": 10}
)
print(f"Bedrock call successful: {response}")
output = response['output']['message']['content'][0]['text'].strip()
score = float(output)
print(f"Score parsed: {score}")
return max(0.0, min(1.0, score))
except Exception as e:
if "ThrottlingException" in str(e) and attempt < max_retries - 1:
time.sleep(2 ** attempt)
else:
print(f"Bedrock call failed: {e}")
return None
return None
def lambda_handler(event, context):
"""AWS Lambda handler - processes samples from RFTEvalInvoker."""
try:
samples = event if isinstance(event, list) else [event]
results = []
for sample in samples:
sample_id = sample.get("id", "unknown")
messages = sample.get("messages", [])
# Extract assistant response (response A)
response_a = ""
for msg in messages:
if msg.get("role") in ["assistant", "nova_assistant"]:
response_a = msg.get("content", "")
break
# Extract reference answer from root level (no longer in metadata)
reference_answer = sample.get("reference_answer", "")
# Handle both string and dict reference_answer formats
if isinstance(reference_answer, dict):
# If reference_answer is a dict, extract the explanation or compliant field
response_b = reference_answer.get("explanation", reference_answer.get("compliant", ""))
else:
response_b = reference_answer
if not response_a or not response_b:
results.append({
"id": sample_id,
"aggregate_reward_score": 0.0,
"metrics_list": [{"name": "similarity_score", "value": 0.0, "type": "Metric"}]
})
continue
# Get similarity score
score = lambda_graded(response_a, response_b)
results.append({
"id": sample_id,
"aggregate_reward_score": score,
"metrics_list": [
{
"name": "similarity_score",
"value": score,
"type": "Metric"
}
]
})
return {"statusCode": 200, "body": json.dumps(results)}
except Exception as e:
print(f"Error: {e}")
return {"statusCode": 500, "body": json.dumps({"error": str(e)})}
```
### 输入格式
Lambda 采用与其他奖励函数相同的输入格式：
```
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don't have a dedicated security team..."
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
},
"my_custom_field": "custom_value"
}
```
### 输出格式
```
{
"id": "sample-001",
"aggregate_reward_score": 0.85,
"metrics_list": [
{
"name": "similarity_score",
"value": 0.85,
"type": "Metric"
}
]
}
```
### 部署注意事项
您可能还需要根据所选模型的能力和 API 格式调整提示模板和推理参数。
+ **IAM 权限**：Lambda 执行角色必须具备对所选模型的 `bedrock:InvokeModel` 调用权限
+ **超时**：将 Lambda 超时设置为至少 60 秒，以适配 Bedrock API 延迟和重试需求
+ **区域**：在所选 Bedrock 模型可用的区域部署
+ **成本**：监控 Bedrock API 使用量，每次评测中每个样本均会发起一次 API 调用
+ **吞吐量**：大规模评测时，申请提升 Bedrock 配额以避免节流
**提高 Bedrock 吞吐量**
如果在评测过程中遇到节流，可提升 Bedrock 模型配额：
+ 进入 AWS 服务配额控制台
+ 搜索 Bedrock 并选择对应区域
+ 找到所选模型的配额项（例如“Claude 3.5 Sonnet 每分钟调用次数”）
+ 点击 “请求增加配额”并指定所需的吞吐量
+ 提供增加配额的理由（例如“RFT 评测工作负载”）
Lambda 内置的重试逻辑可处理偶发节流，而持续高吞吐量评测需相应提升配额。
**所需的 IAM 策略：**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": "arn:aws:bedrock:*::foundation-model/*"
}
]
}
```
# 迭代训练
迭代训练是一种通过多轮训练周期对模型进行微调的系统化方法：每一轮训练都基于上一轮的检查点，通过评估发现模型的具体短板并加以改进。这种方法通过引入针对性示例修复失效场景、适配不断变化的需求，并以渐进式验证的方式提升模型效果，而非仅依赖单次长时间训练。流程通常遵循如下模式：先进行 SFT（监督式微调），再执行 RFT（基于奖励的微调）。模型检查点存储在 AWS 托管式托管 S3 存储桶中，可供后续训练迭代引用，同时在整个流程中保持模型类型与训练技术的一致性。
有关详细信息，请参考 [迭代训练](nova-iterative-training.md)。