# 基于 SageMaker HyperPod 的 Amazon Nova 自定义
基于 SageMaker HyperPod

您可以通过 [Amazon Nova 配方](nova-model-recipes.md)自定义 Amazon Nova 模型（包括增强版 Amazon Nova 2.0 模型），并在 Hyperpod 上完成模型训练。配方是指 YAML 配置文件，该文件向 SageMaker AI 提供有关如何运行模型自定义作业的详细信息。SageMaker HyperPod 支持两种服务类型：Forge 与非 Forge。

HyperPod 使用优化的 GPU 实例和适用于 Lustre 的 Amazon FSx 存储提供高性能计算，通过集成 TensorBoard 等工具实现强大的监控，支持灵活的检查点管理以实现迭代改进，可无缝部署到 Amazon Bedrock 进行推理，并支持高效可扩展的多节点分布式训练。所有这些功能协同工作，为组织提供一个安全、高性能且灵活的环境，以便组织根据其特定业务需求定制 Amazon Nova 模型。

在 SageMaker HyperPod 上进行 Amazon Nova 模型自定义时，会将模型构件（包括模型检查点）存储在服务托管的 Amazon S3 存储桶中。服务托管存储桶中的构件使用 SageMaker AI 托管的 AWS KMS 密钥进行加密。服务托管的 Amazon S3 存储桶目前不支持使用客户托管的 KMS 密钥进行数据加密。您可以利用此检查点位置进行评估作业或 Amazon Bedrock 推理。

标准定价适用于计算实例、Amazon S3 存储和适用于 Lustre 的 FSx。有关定价详情，请参阅 [HyperPod 定价](https://aws.amazon.com/sagemaker-ai/pricing/)、[Amazon S3 定价](https://aws.amazon.com/s3/pricing/)以及[适用于 Lustre 的 FSx 定价](https://aws.amazon.com/fsx/lustre/pricing/)。

## Amazon Nova 2 模型的算力需求


下表汇总了针对 Amazon Nova 2 模型进行 SageMaker HyperPod 和 SageMaker AI 训练作业时的算力需求。


**Nova 2 训练要求**  

| 训练技术 | 最小实例数 | 实例类型 | GPU 计数 | 备注 | 支持的模型 | 
| --- |--- |--- |--- |--- |--- |
| SFT（LoRA） | 4 | P5.48xlarge | 16 | 参数高效微调 | Nova 2 Lite | 
| SFT（全秩） | 4 | P5.48xlarge | 32 | 全模型微调 | Nova 2 Lite | 
| 基于 SageMaker 训练作业进行 RFT（LoRA） | 2 | P5.48xlarge | 16 | 在 AWS 环境中使用自定义奖励函数 | Nova 2 Lite | 
| 基于 SageMaker 训练作业进行 RFT（全秩） | 4 | P5.48xlarge | 32 | 32K 上下文长度 | Nova 2 Lite | 
| 基于 SageMaker HyperPod 进行 RFT | 8 | P5.48xlarge | 64 | 默认 8192 上下文长度 | Nova 2 Lite | 
| CPT | 4 | P5.48xlarge | 16 | 每个实例每天约处理 4 亿词元 | Nova 2 Lite | 

要在 Hyperpod 上优化 Amazon Nova 模型自定义工作流，请遵循以下关于高效训练、资源管理及成功部署模型的最佳实践建议。

## 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 2 模型的算力需求
](#nova-hp-compute-2)
+ [

## Amazon Nova 自定义最佳实践
](#best-practices)
+ [

# Nova Forge SDK
](nova-hp-forge-sdk.md)
+ [

# 创建带有受限实例组（RIG）的 SageMaker HyperPod EKS 集群
](nova-hp-cluster.md)
+ [

# Amazon SageMaker HyperPod 核心命令指南
](nova-hp-essential-commands-guide.md)
+ [

# Nova Forge 访问与设置
](nova-forge-hp-access.md)
+ [

# Amazon Nova 模型训练
](nova-hp-training.md)
+ [

# 评估经过训练的模型
](nova-hp-evaluate.md)
+ [

# 使用 MLflow 监控 HyperPod
](nova-hp-mlflow.md)

# Nova Forge SDK


Amazon Nova Forge SDK 是一套功能完整的 Python SDK，为整个 Amazon Nova 模型自定义生命周期提供统一的编程接口。该 SDK 通过提供统一且一致的 API，简化了模型自定义流程，支持在 Amazon SageMaker 和 Amazon Bedrock 平台上完成训练、评估、监控、部署与推理全流程操作。

有关更多信息，请参阅 [Nova Forge SDK](nova-forge-sdk.md)。

# 创建带有受限实例组（RIG）的 SageMaker HyperPod EKS 集群
HP 集群设置

要在 HyperPod 上对模型进行自定义，必须先完成必要的基础设施设置。如需了解如何设置带有受限实例组（RIG）的 SageMaker HyperPod EKS 集群，请参阅相关[讲习会](https://catalog.us-east-1.prod.workshops.aws/workshops/dcac6f7a-3c61-4978-8344-7535526bf743/en-US)，其中提供了完整的设置步骤详解。

# Amazon SageMaker HyperPod 核心命令指南
核心命令指南

Amazon SageMaker HyperPod 提供丰富的命令行功能，用于管理训练工作流。本指南涵盖常见操作的核心命令，包括连接集群、监控作业进度。

**先决条件**  
使用这些命令前，请确保已完成以下配置：
+ 已创建配备 RIG 的 SageMaker HyperPod 集群（通常在 us-east-1）
+ 已创建用于存储训练构件的 Amazon S3 输出存储桶
+ 已配置具备相应权限的 IAM 角色
+ 已按正确的 JSONL 格式上传训练数据
+ 已完成 FSx for Lustre 同步（首次作业时请在集群日志中验证）

**Topics**
+ [

## 安装配方 CLI
](#nova-hp-essential-commands-guide-install)
+ [

## 连接到集群
](#nova-hp-essential-commands-guide-connect)
+ [

## 启动训练作业
](#nova-hp-essential-commands-guide-start-job)
+ [

## 查看作业状态
](#nova-hp-essential-commands-guide-status)
+ [

## 监控作业日志
](#nova-hp-essential-commands-guide-logs)
+ [

## 列出所有活跃作业
](#nova-hp-essential-commands-guide-list-jobs)
+ [

## 取消作业
](#nova-hp-essential-commands-guide-cancel-job)
+ [

## 运行评估作业
](#nova-hp-essential-commands-guide-evaluation)
+ [

## 常见问题
](#nova-hp-essential-commands-guide-troubleshooting)

## 安装配方 CLI


执行安装命令前，请先导航到配方存储库根目录。

**若使用非 Forge 自定义方案，请使用 Hyperpodrecipes 存储库；若基于 Forge 进行自定义，请参考专属 Forge 的配方存储库。**  
执行以下命令安装 SageMaker HyperPod CLI：

**注意**  
确保并未处于活跃的 conda/anaconda/miniconda 环境或其他虚拟环境中  
若当前处于这样的环境中，请执行以下命令退出：  
conda/anaconda/miniconda 环境：`conda deactivate`
Python 虚拟环境：`deactivate`

 若使用的是非 Forge 自定义技术，请按如下方式下载 sagemaker-hyperpod-recipes 存储库：

```
git clone -b release_v2 https://github.com/aws/sagemaker-hyperpod-cli.git
cd sagemaker-hyperpod-cli
pip install -e .
cd ..
root_dir=$(pwd)
export PYTHONPATH=${root_dir}/sagemaker-hyperpod-cli/src/hyperpod_cli/sagemaker_hyperpod_recipes/launcher/nemo/nemo_framework_launcher/launcher_scripts:$PYTHONPATH
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
rm -f ./get_helm.sh
```

若为 **Forge 订阅用户**，您应按照如下流程下载配方。

```
mkdir NovaForgeHyperpodCLI
cd NovaForgeHyperpodCLI
aws s3 cp s3://nova-forge-c7363-206080352451-us-east-1/v1/ ./ --recursive
pip install -e .

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
rm -f ./get_helm.sh
```

**提示**  
如需在执行 `pip install -e .` 前使用[新的虚拟环境](https://docs.python.org/3/library/venv.html)，请运行：  
`python -m venv nova_forge`
`source nova_forge/bin/activate`
此时命令行提示符开头会显示 (nova\$1forge)
这可确保使用 CLI 时不会出现冲突的依赖项

**目的**：为何要执行 `pip install -e .`？

该命令以可编辑模式安装 SageMaker HyperPod CLI，无需您每次重新安装，即可使用更新后的配方。其同时支持新增配方并被 CLI 自动识别。

## 连接到集群


运行任何任务前，请先使用 SageMaker HyperPod CLI 连接集群：

```
export AWS_REGION=us-east-1 &&  SageMaker HyperPod  connect-cluster --cluster-name <your-cluster-name> --region us-east-1
```

**重要**  
该命令会生成后续命令必需的上下文文件 (`/tmp/hyperpod_context.json`)。若出现文件不存在错误，请重新执行连接命令。

**专业提示**：您可以通过在命令中添加 `--namespace kubeflow` 参数，进一步将集群配置为始终使用 `kubeflow` 命名空间，示例如下：

```
export AWS_REGION=us-east-1 && \
hyperpod connect-cluster \
--cluster-name <your-cluster-name> \
--region us-east-1 \
--namespace kubeflow
```

这样就无需在每条任务命令中都添加 `-n kubeflow`。

## 启动训练作业


**注意**  
若运行 PPO/RFT 任务，请务必在文件 `src/hyperpod_cli/sagemaker_hyperpod_recipes/recipes_collection/cluster/k8s.yaml` 中添加标签选择器配置，确保所有容器组（pod）调度到同一节点。  

```
label_selector:
  required:
    sagemaker.amazonaws.com/instance-group-name:
      - <rig_group>
```

通过配方启动训练作业（支持可选参数覆盖）：

```
hyperpod start-job -n kubeflow \
--recipe fine-tuning/nova/nova_1_0/nova_micro/SFT/nova_micro_1_0_p5_p4d_gpu_lora_sft \
--override-parameters '{
"instance_type": "ml.p5.48xlarge",
    "container": "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-HP-SFT-latest"
  }'
```

**预期输出**：

```
Final command: python3 <path_to_your_installation>/NovaForgeHyperpodCLI/src/hyperpod_cli/sagemaker_hyperpod_recipes/main.py recipes=fine-tuning/nova/nova_micro_p5_gpu_sft cluster_type=k8s cluster=k8s base_results_dir=/local/home/<username>/results cluster.pullPolicy="IfNotPresent" cluster.restartPolicy="OnFailure" cluster.namespace="kubeflow" container="708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:HP-SFT-DATAMIX-latest"

Prepared output directory at /local/home/<username>/results/<job-name>/k8s_templates
Found credentials in shared credentials file: ~/.aws/credentials
Helm script created at /local/home/<username>/results/<job-name>/<job-name>_launch.sh
Running Helm script: /local/home/<username>/results/<job-name>/<job-name>_launch.sh

NAME: <job-name>
LAST DEPLOYED: Mon Sep 15 20:56:50 2025
NAMESPACE: kubeflow
STATUS: deployed
REVISION: 1
TEST SUITE: None
Launcher successfully generated: <path_to_your_installation>/NovaForgeHyperpodCLI/src/hyperpod_cli/sagemaker_hyperpod_recipes/launcher/nova/k8s_templates/SFT

{
 "Console URL": "https://us-east-1.console.aws.amazon.com/sagemaker/home?region=us-east-1#/cluster-management/<your-cluster-name>"
}
```

## 查看作业状态


使用 kubectl 监控运行中的作业：

```
kubectl get pods -o wide -w -n kubeflow | (head -n1 ; grep <your-job-name>)
```

**容器组（pod）状态说明**  
下表说明常见的容器组（pod）状态：


| Status | 说明 | 
| --- |--- |
| `Pending` | 容器组（pod）已被接受，但尚未调度到节点，或正在等待拉取容器映像 | 
| `Running` | 容器组（pod）已绑定到节点，且至少有一个容器正在运行或启动中 | 
| `Succeeded` | 所有容器均成功完成，且不会重启 | 
| `Failed` | 所有容器已终止，且至少有一个容器执行失败 | 
| `Unknown` | 无法确定容器组（pod）状态（通常因节点通信问题导致） | 
| `CrashLoopBackOff` | 容器反复启动失败；Kubernetes 暂缓重启尝试（退避重试） | 
| `ImagePullBackOff` / `ErrImagePull` | 无法从注册表拉取容器映像 | 
| `OOMKilled` | 容器因超出内存限制被终止 | 
| `Completed` | 作业或容器组（pod）成功完成（批处理作业完成） | 

**提示**  
使用 `-w` 参数可实时监控容器组（pod）状态更新，按下 Ctrl\$1C 可停止监控。按下 `Ctrl+C` 可停止监控。

## 监控作业日志


您可通过以下三种方式之一查看日志：

**使用 CloudWatch**  
日志存储在包含 HyperPod 集群的 AWS 账户对应的 CloudWatch 中。如需在浏览器中查看，请导航到账户中的 CloudWatch 主页，然后搜索集群名称。例如，若集群名为 `my-hyperpod-rig`，则日志组的前缀为：
+ **日志组**：`/aws/sagemaker/Clusters/my-hyperpod-rig/{UUID}`
+ 进入日志组后，可通过节点实例 ID（如 `hyperpod-i-00b3d8a1bf25714e4`）定位具体日志。
  + 其中 `i-00b3d8a1bf25714e4` 表示当前训练作业所运行的 HyperPod 节点友好名称。回想一下，在之前执行的命令 `kubectl get pods -o wide -w -n kubeflow | (head -n1 ; grep my-cpt-run)` 的输出中，我们已经获取到了名为 **NODE** 的列。
  + 本例中，“主”节点的作业运行在 hyperpod-`i-00b3d8a1bf25714e4` 上，因此需通过该字符串筛选日志组。选择名称为 `SagemakerHyperPodTrainingJob/rig-group/[NODE]` 的日志流即可查看

**使用 CloudWatch Insights**  
若已掌握作业名称，且不想执行上述全部步骤，可直接在 `/aws/sagemaker/Clusters/my-hyperpod-rig/{UUID}` 下查询所有日志，以定位对应日志。

CPT：

```
fields @timestamp, @message, @logStream, @log
| filter @message like /(?i)Starting CPT Job/
| sort @timestamp desc
| limit 100
```

如需查询作业完成状态，可将 `Starting CPT Job` 替换为 `CPT Job completed`

然后，您可以单击结果，并选择显示“Epoch 0”的结果，因为那将是主节点。

**使用 AWS AWS CLI**  
您也可以通过 AWS CLI 实时跟踪日志。操作前，请先使用 `aws --version` 检查 AWS CLI 版本。建议使用提供的工具脚本，以便在终端中实时跟踪日志

**V1：**

```
aws logs get-log-events \
--log-group-name /aws/sagemaker/YourLogGroupName \
--log-stream-name YourLogStream \
--start-from-head | jq -r '.events[].message'
```

**V2：**

```
aws logs tail /aws/sagemaker/YourLogGroupName \
 --log-stream-name YourLogStream \
--since 10m \
--follow
```

## 列出所有活跃作业


查看集群中所有正在运行的作业：

```
hyperpod list-jobs -n kubeflow
```

**输出示例：**

```
{
  "jobs": [
    {
      "Name": "test-run-nhgza",
      "Namespace": "kubeflow",
      "CreationTime": "2025-10-29T16:50:57Z",
      "State": "Running"
    }
  ]
}
```

## 取消作业


随时停止正在运行的作业：

```
hyperpod cancel-job --job-name <job-name> -n kubeflow
```

**查找作业名称**  
**选项 1：从配方中获取**

作业名称已在配方的 `run` 代码块中指定：

```
run:
  name: "my-test-run"                        # This is your job name
  model_type: "amazon.nova-micro-v1:0:128k"
  ...
```

**选项 2：通过 list-jobs 命令获取**

执行 `hyperpod list-jobs -n kubeflow` 命令，复制输出结果中的 `Name` 字段即可。

## 运行评估作业


使用评估配方对已训练模型或基础模型进行评估。

**先决条件**  
运行评估作业前，确保已准备好以下内容：
+ 来自训练作业的 `manifest.json` 文件的检查点 Amazon S3 URI（适用于经过训练的模型）
+ 已按正确格式上传到 Amazon S3 的评估数据集
+ 用于存储评估结果的 Amazon S3 输出路径

**命令**  
执行以下命令启动评估作业：

```
hyperpod start-job -n kubeflow \
  --recipe evaluation/nova/nova_2_0/nova_lite/nova_lite_2_0_p5_48xl_gpu_bring_your_own_dataset_eval \
  --override-parameters '{
    "instance_type": "p5.48xlarge",
    "container": "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-HP-Eval-latest",
    "recipes.run.name": "<your-eval-job-name>",
    "recipes.run.model_name_or_path": "<checkpoint-s3-uri>",
    "recipes.run.output_s3_path": "s3://<your-bucket>/eval-results/",
    "recipes.run.data_s3_path": "s3://<your-bucket>/eval-data.jsonl"
  }'
```

**参数描述**：
+ `recipes.run.name`：评估作业的唯一名称
+ `recipes.run.model_name_or_path`：来自 `manifest.json` 的 Amazon S3 URI，或基础模型路径（如 `nova-micro/prod`）
+ `recipes.run.output_s3_path`：评估结果的 Amazon S3 存储位置
+ `recipes.run.data_s3_path`：评估数据集的 Amazon S3 存储位置

**提示**：
+ **模型专属配方**：不同规格的模型（micro、lite、pro）对应各自的评估配方
+ **基础模型评测**：评估基础模型时，使用基础模型路径（如 `nova-micro/prod`）而非检查点 URI

**评估数据格式**  
**输入格式（JSONL）**：

```
{
  "metadata": "{key:4, category:'apple'}",
  "system": "arithmetic-patterns, please answer the following with no other words: ",
  "query": "What is the next number in this series? 1, 2, 4, 8, 16, ?",
  "response": "32"
}
```

**输出格式**：

```
{
  "prompt": "[{'role': 'system', 'content': 'arithmetic-patterns, please answer the following with no other words: '}, {'role': 'user', 'content': 'What is the next number in this series? 1, 2, 4, 8, 16, ?'}]",
  "inference": "['32']",
  "gold": "32",
  "metadata": "{key:4, category:'apple'}"
}
```

**字段描述**：
+ `prompt`：发送给模型的格式化输入内容
+ `inference`：模型生成的响应
+ `gold`：输入数据集中的预期正确答案
+ `metadata`：从输入中传递的可选元数据

## 常见问题

+ `nemo_launcher` 您可能需要根据 `hyperpod_cli` 的安装路径，将 `ModuleNotFoundError: No module named 'nemo_launcher'` 添加到 Python 路径中。示例命令：

  ```
  export PYTHONPATH=<path_to_hyperpod_cli>/sagemaker-hyperpod-cli/src/hyperpod_cli/sagemaker_hyperpod_recipes/launcher/nemo/nemo_framework_launcher/launcher_scripts:$PYTHONPATH
  ```
+ `FileNotFoundError: [Errno 2] No such file or directory: '/tmp/hyperpod_current_context.json'` 说明您未执行 hyperpod connect cluster 命令。
+ 若未看到作业被调度，请检查 SageMaker HyperPod CLI 的输出中是否包含任务名称及其他元数据。若未包含，请执行以下命令重新安装 Helm 图表：

  ```
  curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
  chmod 700 get_helm.sh
  ./get_helm.sh
  rm -f ./get_helm.sh
  ```

# Nova Forge 访问与设置
Nova Forge 访问与设置

要设置可用于作业的 Amazon Nova Forge，您需要：
+ 订阅 Amazon Nova Forge
+ 设置集群

**Topics**
+ [

# 订阅 Amazon Nova Forge
](nova-forge-subscribing.md)
+ [

# 设置基础设施
](nova-forge-hyperpod-setup.md)
+ [

# 负责任的人工智能
](nova-forge-responsible-ai.md)

# 订阅 Amazon Nova Forge
订阅 Nova Forge

要访问 Amazon Nova Forge 功能，请完成如下步骤：

1. 验证管理员对 AWS 账户的访问权限。

1. 进入 SageMaker AI 控制台并[请求访问 Amazon Nova Forge](nova-forge.md)。

1. 订阅申请通过后，请等待 Amazon Nova 团队发送确认邮件通知。

1. 使用 `forge-subscription` 标签标记执行角色。标签是访问 Amazon Nova Forge 功能和检查点的必需条件。将以下标签添加到执行角色：
   + 键：`forge-subscription`
   + 值：`true`

**注意**  
无需订阅 Forge，标准 Amazon Nova 功能仍可正常使用。Amazon Nova Forge 专为构建自定义前沿模型而设计，可在模型训练全阶段提供可控性与灵活性。

# 设置基础设施
设置 HyperPod 基础设施

Amazon Nova Forge 订阅获批后，请配置所需基础设施来启用支持 Forge 的功能。有关创建带有受限实例组（RIG）的 EKS 集群的详细说明，请按照[讲习会说明](https://catalog.us-east-1.prod.workshops.aws/workshops/dcac6f7a-3c61-4978-8344-7535526bf743/en-US)进行操作。

# 负责任的人工智能
负责任的人工智能

**内容审核设置**：Amazon Nova Forge 客户可以为 Amazon Nova Lite 1.0 和 Pro 1.0 模型使用可自定义内容审核设置（CCMS）。CCMS 允许您调整内容审核控制，以符合特定的业务需求，同时保持必要的负责任的人工智能保护措施。要确定业务使用案例是否符合 CCMS 条件，请联系 Amazon Web Services 客户经理。

Amazon Nova Forge 提供负责任的人工智能工具包，其中包括训练数据、评估基准测试和运行时控制，以帮助您使模型符合 Amazon Nova 负责任的人工智能指南。

**训练数据**：数据混合中的“RAI”类别包含强调负责任的人工智能原则、安全考虑和负责任技术部署的案例和场景。在持续预训练期间，使用这些数据来负责任地使模型对齐。

**评估**：提供了基准测试任务，用于测试模型检测和拒绝不当、有害或不正确内容的能力。使用这些评估来衡量基础模型性能与自定义模型性能之间的差异。

# Amazon Nova 模型训练
训练

SageMaker HyperPod 支持多种训练 Amazon Nova 模型的技术，包括持续预训练（CPT）、监督式微调（SFT）和强化微调（RFT）。每种技术适用于不同的自定义需求，并可应用于不同版本的 Amazon Nova 模型。

**Topics**
+ [

# 持续预训练 (CPT)
](nova-cpt.md)
+ [

# 监督式微调（SFT）
](nova-fine-tune.md)
+ [

# SageMaker HyperPod 上的强化微调（RFT）
](nova-hp-rft.md)

# 持续预训练 (CPT)
持续预训练 (CPT)

持续预训练（CPT）是一种通过让基础模型接触来自特定领域或语料库的额外无标注文本，从而延长模型预训练阶段的训练技术。监督式微调需要带标注的输入-输出样本对，而 CPT 直接基于原始文档进行训练，帮助模型掌握更深的新领域知识、学习领域专属术语与行文风格，并适配特定内容类型或主题领域。

当您拥有海量（数百亿词元级）的领域专属文本数据（如法律文书、医学文献、技术文档或企业专有内容），并希望模型在该领域具备原生流畅度时，这种方法尤为适用。通常，在 CPT 阶段之后，模型还需要经过额外的指令微调阶段，才能将新学到的知识用于完成实际任务。

**支持的模型**  
CPT 适用于以下 Amazon Nova 模型：
+ Nova 1.0（Micro、Lite、Pro）
+ Nova 2.0（Lite）

**何时选用 Nova 1.0 与 Nova 2.0**  
Amazon Nova 系列模型提供多种高性价比方案，助力在精准度、速度与成本之间实现最优平衡。

需要以下特性时，建议选择 Nova 2.0：
+ 具备适用于复杂分析任务的高级推理能力
+ 在代码生成、数学及科学问题求解方面表现更出色
+ 支持更长的上下文长度
+ 具备更优的多语言处理能力

**注意**  
模型并非越大越优。在 Nova 1.0 与 Nova 2.0 之间选型时，请综合考虑性价比与具体业务需求。

# Nova 2.0 上的 CPT


Amazon Nova Lite 2.0 是一款推理模型，其训练所用数据集相较于 Nova Lite 1.0 规模更大、种类更更富。虽然 Nova Lite 2.0 模型规模更大，但其推理速度却快于 Nova Lite 1.0，同时具备更强的推理能力、更长的上下文长度以及更优的多语言处理性能。

借助 Nova 2.0 上的 CPT，您可通过自身领域专属数据拓展这些高级能力，使模型在专业领域形成深度专长，同时保持其出色的推理与分析能力。

## CPT 配方示例


以下是 CPT 配方示例。您可以在[配方](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/training/nova)存储库中找到此配方和其他配方。

```
# Note:
# This recipe can run on p5.48xlarge
# Run config
run:
  name: "my-cpt-run"                           # A descriptive name for your training job
  model_type: "amazon.nova-2-lite-v1:0:256k"   # Model variant specification, do not change
  model_name_or_path: "nova-lite-2/prod"        # Base model path, do not change
  replicas: 8                                   # Number of compute instances for training, allowed values are 4, 8, 16, 32
  data_s3_path: ""                              # Customer data paths
  validation_data_s3_path: ""                   # Customer validation data paths
  output_s3_path: ""                            # Output artifact path,  job-specific configuration - not compatible with standard SageMaker Training Jobs
  mlflow_tracking_uri: ""                       # Required for MLFlow
  mlflow_experiment_name: "my-cpt-experiment"   # Optional for MLFlow. Note: leave this field non-empty
  mlflow_run_name: "my-cpt-run"                 # Optional for MLFlow. Note: leave this field non-empty

## Training specific configs
training_config:
  task_type: cpt
  max_length: 8192                              # Maximum context window size (tokens)
  global_batch_size: 256                        # Global batch size, allowed values are 32, 64, 128, 256.

  trainer:
    max_steps: 10                               # The number of training steps to run total
    val_check_interval: 10                      # The number of steps between running validation. Integer count or float percentage
    limit_val_batches: 2                        # Batches of the validation set to use each trigger

  model:
    hidden_dropout: 0.0                         # Dropout for hidden states, must be between 0.0 and 1.0
    attention_dropout: 0.0                      # Dropout for attention weights, must be between 0.0 and 1.0

  optim:
    optimizer: adam
    lr: 1e-5                                    # Learning rate
    name: distributed_fused_adam                # Optimizer algorithm, do not change
    adam_w_mode: true                           # Enable AdamW mode
    eps: 1e-06                                  # Epsilon for numerical stability
    weight_decay: 0.0                           # L2 regularization strength, must be between 0.0 and 1.0
    adam_beta1: 0.9                             # Beta1 for Adam optimizer
    adam_beta2: 0.95                            # Beta2 for Adam optimizer
    sched:
      warmup_steps: 10                          # Learning rate warmup steps
      constant_steps: 0                         # Steps at constant learning rate
      min_lr: 1e-6                              # Minimum learning rate, must be lower than lr
```

## 为 2.0 上的 CPT 做数据准备


**数据格式要求**  
训练数据集与验证数据集必须为 JSONL 文件，并遵循以下格式：每行包含一个 JSON 对象，用于表示一段对话，且需包含必填字段与指定结构。示例如下：

```
{"text": "AWS stands for Amazon Web Services"}
{"text": "Amazon SageMaker is a fully managed machine learning service"}
{"text": "Amazon Bedrock is a fully managed service for foundation models"}
```

文本条目应包含代表目标领域的自然流畅的高质量内容。

测试数据是否能够转换为 [Arrow 格式](https://huggingface.co/docs/datasets/en/about_arrow)。使用下方的 python 脚本来解决这个问题。确保至少使用 `datasets==2.18.0` 版本：

```
from datasets import load_dataset, load_from_disk
from pathlib import Path

input_path = Path("<Your jsonl file>")
output_path = Path("<Your output directory>")

dataset = load_dataset("json", data_files=str(input_path), split="train")
dataset.save_to_disk(str(output_path), max_shard_size="1GB")

try:
  test_dataset = datasets.load_from_disk(output_dir)
  print(f"Dataset loaded successfully ✅! Contains {len(test_dataset)} samples")
except Exception as e:
  print(e)
```

打印的行数应与 JSONL 文件中的行数相同。

使用数据混合时，首个作业请设置 `max_steps=2`。这有助于在集群中为数据访问生成优化配置，并确保所有数据混合均可用。

**如何为 CPT 准备数据**  
训练数据是决定持续预训练能否成功的最关键因素。虽然 CPT 数据常被称作“无标注数据”，但实际情况远比这复杂。数据的结构、格式与呈现方式，直接决定模型能否习得使用案例所需的知识与能力。

### 为 CPT 准备结构化的业务数据集


这对于构建专属领域基础模型的企业与机构而言，是一项普遍挑战。多数企业都拥有丰富的结构化数据资源，包括产品目录、用户档案、交易日志、表单提交记录、API 调用信息及运营元数据等。乍看之下，这类数据与标准预训练中常用的非结构化 Web 文本差异显著。

若要让模型从结构化业务数据中高效学习，需充分考量下游任务，并合理设计数据呈现方式，引导模型学习正确的预测关联。

要充分发挥持续预训练的潜力，需考虑以下几点：
+ 模型在推理阶段需执行的任务
+ 原始数据中包含的信息
+ 如何对数据进行结构化处理，使模型能够正确提取并运用信息

将结构化数据直接用于训练，无法让模型掌握相关推理能力。需主动调整数据的呈现方式，引导模型的学习方向。

以下章节将通过后续章节将通过文献综述阐述数据增强的重要性，并给出结构化业务数据的数据增强策略示例，为您在 CPT 中处理与组织业务数据集提供实用参考。

**文献中的 CPT 结构化数据**  
CPT 能够将领域事实注入模型，但在输入或任务发生变化时，模型往往难以有效检索和运用这些事实。对照实验表明，若预训练阶段未采用多样化数据增强，模型会以僵化方式记忆事实信息，即便后续开展指令微调，也依然难以提取利用。相关研究建议在训练初期就注入类指令信号。对于半结构化数据，随机序列化及其他增强手段可降低架构过拟合，因此 CPT 应与指令类任务交替进行，而非先执行 CPT 再开展 IFT。金融领域相关研究进一步发现，相较于分步执行配方，在批次层面混合 CPT 与指令数据，可提升泛化能力并减少知识遗忘。Qwen 技术报告也得出一致结论：将高质量指令数据融入预训练本身，可使模型在学习新领域知识的同时，增强上下文学习能力并保持指令遵循能力。

对半结构化语料库实施数据增强是关键手段。合成图感知 CPT 可将小规模领域数据集扩展为实体关联语料库，显式学习实体关系与复合结构，并在推理阶段结合检索能力使用。在金融领域，CPT 与指令数据混合训练的效果优于分步流程；同时，利用通用数据平衡领域数据可减轻模型通用能力的退化。大规模领域 CPT 也能保留较广泛的通用能力，甚至可通过模型融合进行取舍，但研究仍表明指令微调是必不可少的后续步骤，这进一步印证了在 CPT 阶段引入指令信号的重要价值。

**通过随机化和乱序注入多样性**  
一种能帮助模型从结构化及半结构化数据集中高效学习的通用策略，是打乱数据集中字段的顺序，甚至随机丢弃部分键值。

打乱字段顺序可迫使模型去理解每个值的具体含义，而非依赖其出现位置，并学习所有字段间的关联关系。例如，以 Amazon 商店上架的某款电子游戏数据为例，当“标题”“平台”“价格”“品相”“版本”等字段以不同顺序排列时，模型无法再依赖“第三个字段是平台”这类位置信息，而必须将标签与对应值绑定，进而掌握各属性间的双向关联：标题 ⇄ 平台、平台 ⇄ 价格、品相 ⇄ 价格。如此一来，模型便能实现诸多实用推理，比如根据游戏名称和观察到的价格推断可能的平台，或依据标题与平台估算合理的价格区间。

在序列化过程中随机丢弃键值，其作用类似于特征丢弃：可防止模型对任一单个字段产生共适应现象，进而迫使模型从剩余的有效信息中还原缺失内容。若“平台”字段缺失，模型需从标题字符串或兼容性文本中提取平台相关信息；若“价格”字段被隐藏，模型则需结合平台、版本及品相信息进行综合推断。这不仅建立了双向对称性（A→B 与 B→A），增强了对杂乱真实世界列表的稳健性，还能在字段缺失、重命名或顺序调整时保持结构不变性。

下面以购物场景示例具体说明。对同一商品采用多种序列化方式，例如“标题：《艾尔登法环》\$1 平台：PlayStation 5 \$1 品相：二手如新 \$1 价格：34.99 美元”，以及另一种排列形式“价格：34.99 美元 \$1 标题：《艾尔登法环》\$1 品相：二手如新 \$1 平台：PlayStation 5”；在部分训练轮次中，可删除“平台”字段，但在描述中保留“兼容 PS5”的相关表述。同时训练互补性目标，比如根据 \$1标题、价格\$1 推断平台，以及根据 \$1标题、平台\$1 确定价格区间。由于字段的顺序甚至存在与否均会随机变化，模型唯一稳定的学习策略，就是掌握各属性之间的真实关联，而非机械记忆固定模板。

### 数据的呈现方式至关重要


LLM 通过从已看到的内容中预测下一个词元来学习。因此，训练期间显示的字段和事件的顺序决定了模型能够学习到什么。如果训练格式与实际任务相匹配，损失就会落在确切的决策词元上。如果字段没有结构地随意堆叠，模型会学习捷径或记忆热门内容，这导致模型在需要从多个选项中做出选择时失败。

先展示情境，再展示选项，最后展示决策。如果模型还需要学习结果或解释，则将其放在决策之后。

### 为 CPT 打包样本


**什么是打包？**  
简单来说，打包就是将多个完整样本填入训练数据中的每个序列窗口，使窗口内充满有效词元，而非填充符。

**为什么这非常重要**  
训练时，设置最大上下文长度，例如 8192 个词元。批次格式为 [批次大小 x 上下文长度]。如果某个训练样本长度不足上下文长度，剩余位置将用填充符补齐。即使在损失计算中对填充部分进行掩码处理，这些填充内容仍会参与注意力机制与 MLP 内核运算，从而消耗算力却不产生任何学习信号。

**如何打包？**  
打包多个样本时，可使用 ` [DOC] ` 分隔符将多个训练样本拼接（注意 [DOC] 前后各保留一个空格），使拼接后的总长度不超过目标上下文长度。

打包后的文档示例如下：

```
{"text": "training sample 1 [DOC] training sample 2 [DOC] training sample 3"}
```

### CPT 调优参数


可用于 CPT 微调的参数包括：

**运行配置**  

+ **name**：训练作业的描述性名称。这有助于在 AWS 管理控制台中识别对应作业。
+ **model\$1type**：要使用的 Amazon Nova 模型变体。可用选项为 `amazon.nova-2-lite-v1:0:256k`。
+ **model\$1name\$1or\$1path**：用于训练的基本模型的路径。可用选项为 `nova-lite-2/prod`，或训练后检查点的 S3 路径 (`s3://customer-escrow-bucket-unique_id/training_run_name`)。
+ **replicas**：要在分布式训练中使用的计算实例数。可用值因您所选的模型而异。Amazon Nova Lite 2.0 支持 4、8、16 或 32 个副本。
+ **data\$1s3\$1path**：训练数据集的 S3 位置，格式为 JSONL 文件。此文件必须与集群位于同一 AWS 账户和区域中。提供的所有 S3 位置必须位于同一账户和区域中。
+ **validation\$1data\$1s3\$1path**：（选填）验证数据集的 S3 位置，格式为 JSONL 文件。此文件必须与集群位于相同的账户和区域中。提供的所有 S3 位置必须位于同一账户和区域中。
+ **output\$1s3\$1path**：存储清单和 TensorBoard 日志的 S3 位置。提供的所有 S3 位置必须位于同一 AWS 账户和 AWS 区域中。
+ **mlflow\$1tracking\$1uri**：用于 MLflow 日志记录的 MLflow 应用程序的 ARN
+ **mlflow\$1experiment\$1name**：MLflow 实验名称
+ **mlflow\$1run\$1name**：MLflow 运行名称

**训练配置**  

+ **max\$1length**：以词元为单位的最大序列长度。这决定了训练的上下文窗口大小。CPT 支持的最大值为 8192 个词元。

  更长的序列将会提高训练效率，但会以增加内存需求为代价。建议将 max\$1length 参数设置为与数据分布相匹配。
+ **global\$1batch\$1size**：所有设备与 Worker 节点在一次前向及反向传播中共同处理的训练样本总数。

  该值乘以每台设备的批量大小和设备数量。它会影响训练的稳定性和吞吐量。我们建议从适合您内存的批量大小开始，然后进行扩展。对于特定领域的数据，较大的批量大小可能会使梯度过于平滑。

**训练器设置**  

+ **max\$1steps**：训练迭代步数。每一步训练模型所用的元素数量即 `global_batch_size`

**模型设置**  

+ **hidden\$1dropout**：隐藏状态输出的丢弃概率。将该值增加约 0.0 到 0.2，以减少对较小数据集的过度拟合。有效值介于 0 到 1 之间（含两端值）。
+ **attention\$1dropout**：注意力权重的丢弃概率。此参数有助于泛化。有效值介于 0 到 1 之间（含两端值）。

**优化器配置**  

+ **lr**：学习率，控制优化期间的步长。为了获得良好的性能，我们建议使用介于 1e-6 和 1e-4 之间的值。有效值介于 0 到 1 之间（含两端值）。
+ **name**：优化器算法。目前仅支持 `distributed_fused_adam`。
+ **weight\$1decay**：L2 正则化强度。值比较高（介于 0.01 到 0.1 之间）会增加正则化强度。
+ **warmup\$1steps**：逐步提高学习率的步数。这可以提高训练稳定性。有效值介于 1 到 20 之间（含两端值）。
+ **min\$1lr**：衰减结束时的最低学习率。有效值介于 0 到 1 之间（含两端值），但必须小于学习率。

# 监督式微调（SFT）
监督式微调（SFT）

SFT 训练流程主要包含两个阶段：
+ **数据准备**：遵循既定指南，创建、清理或重新格式化数据集，使其符合所需结构。确保输入、输出和辅助信息（例如推理轨迹或元数据）正确对齐和格式化。
+ **训练配置**：定义模型的训练方式。使用时，此配置是在 YAML 配方文件中编写的，包括：
  + 数据来源路径（训练和验证数据集）
  + 关键超参数（epoch、学习率、批次大小）
  + 可选组件（分布式训练参数等）

## Nova 模型对比与选型


Amazon Nova 2.0 模型的训练数据集比 Nova 1.0 模型规模更大、种类更丰富。重要改进包括：
+ **增强的推理能力**，支持显式推理模式
+ **更广泛的多语言性能**，覆盖更多语种
+ 在代码生成、工具调用等**复杂任务上表现更优**
+ **扩展的上下文处理能力**，在更长上下文中实现更高的准确性和稳定性

## 何时选用 Nova 1.0 与 Nova 2.0


满足以下条件时，建议选择 Amazon Nova 2.0：
+ 需要具有高级推理能力的卓越性能
+ 需要多语言支持或复杂的任务处理
+ 需要在代码生成、工具调用或分析任务上获得更优效果

# Nova 2.0 上的 SFT


Amazon Nova Lite 2.0 提供增强型监督式微调功能，包括高级推理模式、经改进的多模态理解和经扩展的上下文处理。Nova 2.0 上的 SFT 使您能够针对自己的特定使用案例适配这些强大功能，同时保持模型在处理复杂任务时的卓越性能。

Nova 2.0 上的 SFT 的主要特性包括：
+ **推理模式支持**：训练模型在给出最终答案前生成显式推理轨迹，从而增强分析能力。
+ **高级多模态训练**：针对文档理解（PDF）、视频理解和基于图像的任务进行微调，准确率更高。
+ **工具调用功能**：训练模型有效使用外部工具和函数调用，以应对复杂工作流。
+ **经扩展的上下文支持**：利用更长的上下文窗口，在文档密集型应用中获得更佳的稳定性和准确率。

**注意**  
有关适用的容器映像或示例配方的更多信息，请访问 [Amazon Nova 配方](nova-model-recipes.md)。

**Topics**
+ [

## 推理模式选择（仅限 Nova 2.0）
](#nova-sft-2-reasoning-mode)
+ [

## 工具调用数据格式
](#nova-sft-2-tool-calling)
+ [

## 文档理解数据格式
](#nova-sft-2-document-understanding)
+ [

## SFT 视频理解
](#nova-sft-2-video-understanding)
+ [

## 数据上传说明
](#nova-sft-2-data-upload)
+ [

## 创建微调作业
](#nova-sft-2-creating-job)
+ [

## SFT 调优参数
](#nova-sft-2-tuning-parameters)
+ [

## 超参数指导
](#nova-sft-2-hyperparameters)

## SFT 配方示例


以下是 SFT 配方示例。您可以在[配方](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/nova)存储库中找到此配方和其他配方。

```
run:
  name: my-full-rank-sft-run
  model_type: amazon.nova-2-lite-v1:0:256k
  model_name_or_path: nova-lite-2/prod
  data_s3_path: s3://my-bucket-name/train.jsonl  #  only and not compatible with SageMaker Training Jobs
  replicas: 4                                     # Number of compute instances for training, allowed values are 4, 8, 16, 32
  output_s3_path: s3://my-bucket-name/outputs/    # Output artifact path (HyperPod job-specific; not compatible with standard SageMaker Training Jobs)
  mlflow_tracking_uri: ""                         # Required for MLFlow
  mlflow_experiment_name: "my-full-rank-sft-experiment"  # Optional for MLFlow. Note: leave this field non-empty
  mlflow_run_name: "my-full-rank-sft-run"         # Optional for MLFlow. Note: leave this field non-empty

training_config:
  max_steps: 100                    # Maximum training steps. Minimal is 4.
  save_steps: ${oc.select:training_config.max_steps}  # How many training steps the checkpoint will be saved
  save_top_k: 5                     # Keep top K best checkpoints. Note supported only for  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
    adam_beta2: 0.95                 # Exponential decay rate for second-moment estimates

  peft:                             # Parameter-efficient fine-tuning (LoRA)
    peft_scheme: "null"             # Disable LoRA for PEFT
```

## 推理模式选择（仅限 Nova 2.0）


Amazon Nova 2.0 支持推理模式，可进一步提升分析能力：
+ **推理模式（已启用）**：
  + 在训练配置中设置 `reasoning_enabled: true`
  + 模型训练可在给出最终答案之前生成推理轨迹
  + 在复杂推理任务中获得更优性能
+ **非推理模式（已禁用）**：
  + 设置 `reasoning_enabled: false` 或省略参数（默认）
  + 无显式推理的标准 SFT
  + 适用于无需分步推理即可完成的任务

**注意**  
启用推理后，模型会进行高强度推理。SFT 不提供低推理模式选项。
不支持 SFT 多模态推理内容。推理模式适用于纯文本输入。

### 对非推理数据集使用推理模式


您可在 `reasoning_enabled: true` 的情况下，使用非推理数据集训练 Amazon Nova。但是，这样做可能导致模型丧失推理能力，因为 Amazon Nova 会主要学习直接生成数据中的应答，而不进行推理。

如果使用非推理数据集训练 Amazon Nova，但仍想在推理过程中使用推理模式：

1. 在训练期间禁用推理模式 (`reasoning_enabled: false`)

1. 稍后在推理过程中启用推理模式

虽然这种方法可在推理阶段启用推理模式，但相较于不使用推理模式的推理过程，无法保证获得更优效果。

**最佳实践：**在使用推理数据集时，应同时为训练和推理过程启用推理模式；在使用非推理数据集时，应同时为两者禁用推理模式。

**注意**  
有关适用的容器映像或示例配方的更多信息，请访问 [Amazon Nova 配方](nova-model-recipes.md)。

## 工具调用数据格式


SFT 支持训练模型使用工具（函数调用）。以下是用于调用工具的示例输入格式：

**示例输入：**

```
{
  "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 只能出现在助手轮次中
+ ToolResult 只能出现在用户轮次中
+ ToolResult 只能是文本或 JSON；Amazon Nova 模型目前不支持其他模态
+ toolSpec 中的 inputSchema 必须是有效的 JSON 架构对象
+ 每个 ToolResult 必须引用前序助手轮次 ToolUse 中的有效 toolUseId，且每个 toolUseId 在单次对话中仅可使用一次

**注意**  
有关适用的容器映像或示例配方的更多信息，请访问 [Amazon Nova 配方](nova-model-recipes.md)。

## 文档理解数据格式


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?"
        },
        {
          "document": {
            "format": "pdf",
            "source": {
              "s3Location": {
                "uri": "s3://my-bucket-name/path/to/documents/customer_service_debugging.pdf",
                "bucketOwner": "123456789012"
              }
            }
          }
        }
      ]
    },
    {
      "role": "assistant",
      "content": [
        {
          "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?"
        }
      ],
      "reasoning_content": [
        {
          "text": "I need to find the relevant section in the document to answer the question.",
          "type": "text"
        }
      ]
    }
  ]
}
```

文档理解的重要注意事项：
+ 仅支持 PDF 文件
+ 最大文档为 10 MB
+ 单个样本可包含文档与文本，但不可将文档与其他模态（如图像、视频）混用

**注意**  
有关适用的容器映像或示例配方的更多信息，请访问 [Amazon Nova 配方](nova-model-recipes.md)。

## SFT 视频理解


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": [
        {
          "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?"
        }
      ],
      "reasoning_content": [
        {
          "text": "I need to find the relevant section in the video to answer the question.",
          "type": "text"
        }
      ]
    }
  ]
}
```

视频理解的重要注意事项：
+ 视频大小最大 50 MB
+ 视频时长最长 15 分钟
+ 每个样本仅允许包含一个视频；不支持在同一样本中使用多个视频
+ 单个样本可包含视频与文本，但不可将视频与其他模态（如图像、文档）混用

**注意**  
有关适用的容器映像或示例配方的更多信息，请访问 [Amazon Nova 配方](nova-model-recipes.md)。

## 数据上传说明


将训练数据集与验证数据集上传到 S3 存储桶。在配方的 `run` 数据块中指定以下路径：

```
## Run config
run:
  ...
  data_s3_path: "s3://<bucket-name>/<training-directory>/<training-file>.jsonl"
```

**注意**：将 `<bucket-name>`、`<training-directory>`、`<validation-directory>`、`<training-file>` 和 `<validation-file>` 替换为实际的 S3 路径。

**注意**：Amazon Nova 2.0 SFT 目前不支持验证数据集。如果传入验证数据集，系统将忽略该数据集。

## 创建微调作业


使用 `run` 数据块中的 `model_type` 和 `model_name_or_path` 字段定义基础模型：

```
## Run config
run:
  ...
  model_type: amazon.nova-2-lite-v1:0:256k
  model_name_or_path: nova-lite-2/prod
  ...
```

## SFT 调优参数


可用于 SFT 调优的参数包括：

**运行配置**  

+ **name**：训练作业的描述性名称。这有助于在 AWS 管理控制台中识别对应作业。
+ **model\$1type**：要使用的 Amazon Nova 模型变体。可用选项为 `amazon.nova-2-lite-v1:0:256k`。
+ **model\$1name\$1or\$1path**：用于训练的基本模型的路径。可用选项为 `nova-lite-2/prod`，或训练后检查点的 S3 路径 (`s3://customer-escrow-bucket-unique_id/training_run_name`)。
+ **replicas**：要在分布式训练中使用的计算实例数。可用值因您所选的模型而异。Amazon Nova Lite 2.0 支持 4、8、16 或 32 个副本。
+ **data\$1s3\$1path**：训练数据集的 S3 位置，格式为 JSONL 文件。此文件必须与集群位于同一 AWS 账户和区域中。提供的所有 S3 位置必须位于同一账户和区域中。
+ **validation\$1data\$1s3\$1path**：（选填）验证数据集的 S3 位置，格式为 JSONL 文件。此文件必须与集群位于相同的账户和区域中。提供的所有 S3 位置必须位于同一账户和区域中。
+ **output\$1s3\$1path**：存储清单和 TensorBoard 日志的 S3 位置。提供的所有 S3 位置必须位于同一 AWS 账户和 AWS 区域中。
+ **mlflow\$1tracking\$1uri**：用于 MLflow 日志记录的 MLflow 应用程序的 ARN。
+ **mlflow\$1experiment\$1name**：MLflow 实验名称。
+ **mlflow\$1run\$1name**：MLflow 运行名称。

**训练配置**  

+ **max\$1steps**：训练迭代步数。每一步训练模型所用的元素数量即 `global_batch_size`。
+ **save\$1steps**：训练期间保存模型检查点的频率（以步为单位）。
+ **save\$1top\$1k**：根据验证指标保留的最佳检查点的最大数量。
+ **max\$1length**：以词元为单位的最大序列长度。这决定了训练的上下文窗口大小。SFT 支持的最大值为 32768 个词元。

  更长的序列将会提高训练效率，但会以增加内存需求为代价。建议将 max\$1length 参数设置为与数据分布相匹配。
+ **global\$1batch\$1size**：所有设备与 Worker 节点在一次前向及反向传播中共同处理的训练样本总数。

  该值乘以每台设备的批量大小和设备数量。它会影响训练的稳定性和吞吐量。我们建议从适合您内存的批量大小开始，然后进行扩展。对于特定领域的数据，较大的批量大小可能会使梯度过于平滑。
+ **reasoning\$1enabled**：布尔标志，用于在训练期间启用推理功能。

**学习率调度器**  

+ **warmup\$1steps**：逐步提高学习率的步数。这可以提高训练稳定性。
+ **min\$1lr**：衰减结束时的最低学习率。有效值介于 0 到 1 之间（含两端值），但必须小于学习率。

**优化器配置**  

+ **lr**：学习率，控制优化期间的步长。为了获得良好的性能，我们建议使用介于 1e-6 和 1e-4 之间的值。有效值介于 0 到 1 之间（含两端值）。
+ **weight\$1decay**：L2 正则化强度。值比较高（介于 0.01 到 0.1 之间）会增加正则化强度。
+ **adam\$1beta1**：Adam 优化器中一阶矩估计的指数衰减率。默认值为 0.9。
+ **adam\$1beta2**：Adam 优化器中二阶矩估计的指数衰减率。默认值为 0.95。

**PEFT 配置**  

+ **peft\$1scheme**：要使用的参数高效微调方案。全秩微调的可选值为 `'null'`；基于 LoRA 的微调可选值为 `lora`。

**LoRA 微调（当 peft\$1scheme 为 lora 时）**  

+ **alpha**：LoRA 缩放参数。控制低秩适应的幅度。典型值范围为 8 到 128。
+ **lora\$1plus\$1lr\$1ratio**：LoRA\$1 优化中的学习率比例。该乘数会专门针对 LoRA 参数调整学习率。

## 超参数指导


根据训练方法，建议采用如下超参数：

**全秩训练**
+ **epoch**：1
+ **学习率（lr）**：1e – 5
+ **最低学习率（min\$1lr）**：1e – 6

**LoRA（低秩适应）**
+ **epoch**：2
+ **学习率（lr）**：5e – 5
+ **最低学习率（min\$1lr）**：1e – 6

**注意**：请根据数据集规模和验证性能调整这些值。监控训练指标以防止过拟合。

# SageMaker HyperPod 上的强化微调（RFT）
强化微调（RFT）

强化微调（RFT）是一种机器学习技术，它通过反馈信号（即可衡量响应质量的分数或奖励）提升模型性能，而非借助精确标准答案进行直接监督。与从输入-输出对中学习的传统监督式微调不同，RFT 使用奖励函数评测模型响应，并迭代优化模型以最大化奖励。

这种方法尤其适用于难以定义精确输出但能可靠衡量响应质量的任务。RFT 使模型能够通过尝试和反馈来学习复杂的行为与偏好，因此非常适合需要精细决策、创造性解决问题，或遵守可通过编程方式评测的特定质量标准等应用场景。

**何时使用 RFT**  
当您能够定义清晰、可衡量的成功标准，但难以提供精确的正确输出用于训练时，便可使用 RFT。该方法适用于质量具有主观性或多维度的任务，例如创意写作、代码优化或复杂推理。这类任务存在多种可行方案，但部分方案明显更优。

RFT 在以下条件下效果最佳：
+ 具备可通过程序评测模型输出的可靠奖励函数
+ 需要使模型行为与特定偏好或约束保持一致
+ 传统监督式微调因高质量标注数据采集成本高昂或不切实际而难以奏效的场景

应用需要迭代优化、个性化，或需遵循可编码为奖励信号的复杂业务规则时，可考虑采用 RFT。

**RFT 最适合哪些场景**  
在输出质量可客观衡量、但最优应答难以预先定义的领域，RFT 表现优异：
+ **数学问题求解**：存在多种求解路径，但正确性可验证
+ **代码生成和优化**：执行结果与性能指标可测试
+ **科学推理任务**：逻辑一致性与事实准确性
+ **结构化数据分析**：可通过编程方式验证输出
+ **多步推理**：需逐步逻辑推演的任务
+ **工具使用和 API 调用**：成功与否可通过执行结果来衡量
+ **复杂的工作流程**：遵守特定约束和业务规则

当您需要平衡多个相互竞争的目标（如准确性、效率和风格）时，RFT 效果尤为出色。

**何时在 RFT 训练中使用推理模式**  
Amazon Nova 2.0 支持在 RFT 训练期间使用推理模式。可用模式如下：
+ **none**：无推理（省略 reasoning\$1effort 字段）
+ **low**：最小推理开销
+ **high**：最大推理能力（指定了 reasoning\$1effort 时，此为默认值）

**注意**  
RFT 无中等选项。如果配置中不含 reasoning\$1effort 字段，则禁用推理。

在以下场景使用高强度推理：
+ 复杂分析任务
+ 数学问题求解
+ 多步逻辑推导
+ 逐步思考能带来价值的任务

在以下场景使用无（省略 reasoning\$1effort）或低强度推理：
+ 简单事实查询
+ 直接分类
+ 速度与成本优化
+ 直接问答

**重要**  
较高强度的推理模式会增加训练时间和成本、推理延迟和成本，但同时也会提升模型在复杂推理任务方面的能力。

**支持的模型**  
SageMaker HyperPod 上的 RFT 支持 Amazon Nova Lite 2.0（amazon.nova-2-lite-v1:0:256k）。

**主要步骤**  
RFT 过程包括四个关键阶段：
+ **实现评测器**：创建奖励函数，根据质量标准以编程方式对模型响应进行评分。
+ **上传提示**：准备并上传指定对话格式的训练数据，同时提供用于评测的参考数据。
+ **开始作业**：使用配置的参数启动强化微调过程。
+ **监控**：通过指标控制面板跟踪训练进度，确保模型有效学习。

每个步骤都建立在前一步的基础上，其中评测器是指导整个训练过程的基础，它通过提供一致的反馈信号来引导模型学习。

**Topics**
+ [

# Nova 2.0 上的 RFT
](nova-hp-rft-nova2.md)

# Nova 2.0 上的 RFT


RFT 训练数据遵循 OpenAI 对话格式。每个训练样本都是一个 JSON 对象，包含消息、参考答案及可选的工具定义。本节提供相关的指导说明，帮助您了解如何为 Nova 2.0 上的 RFT 准备有效训练数据。

**Topics**
+ [

## 数据格式与结构
](#nova-hp-rft-data-format)
+ [

## 字段描述
](#nova-hp-rft-field-descriptions)
+ [

## 超参数指导
](#nova-hp-rft-monitoring-hyperparams)
+ [

## 其它属性
](#nova-hp-rft-additional-properties)
+ [

## 数据集规模建议
](#nova-hp-rft-dataset-size)
+ [

## 有效训练数据的特征
](#nova-hp-rft-effective-data)
+ [

# 监控 RFT 训练
](nova-hp-rft-monitoring.md)

## 数据格式与结构


每个训练样本都是一个 JSON 对象，其中包含：
+ **messages**：使用系统、用户和可选的助手角色进行的对话轮次数组
+ **reference\$1answer**：用于奖励计算的预期输出或评测标准
+ **tools**（选填）：可供模型使用的函数定义数组
+ **id**（选填）：用于跟踪和去重的唯一标识符

每个样本需单独占一行，JSONL 文件中每行对应一个 JSON 对象。

### 示例 1：化学问题


以下示例是一个化学问题，其参考答案包含真实值：

```
{  
  "id": "chem-001",  
  "messages": [  
    {  
      "role": "system",  
      "content": "You are a helpful chemistry assistant"  
    },  
    {  
      "role": "user",  
      "content": "Predict hydrogen bond donors and acceptors for this SMILES: CCN(CC)CCC(=O)c1sc(N)nc1C"  
    }  
  ],  
  "reference_answer": {  
    "donor_bond_counts": 2,  
    "acceptor_bond_counts": 4,  
    "explanation": "Calculated using Lipinski's rule of five: N-H groups (2 donors), N and O atoms with lone pairs (4 acceptors)"  
  }  
}
```

**注意**  
reference\$1answer 包含使用领域特定规则计算得出的真实值。奖励函数会将模型的预测值与这些参考值进行比较，以计算奖励分数。

### 示例 2：数学问题


以下示例是一个包含求解步骤的数学问题：

```
{  
  "id": "math-001",  
  "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"]  
  }  
}
```

### 示例 3：工具使用


以下示例显示了工具使用及预期行为：

```
{  
  "id": "tool-001",  
  "messages": [  
    {  
      "role": "system",  
      "content": "You are a helpful game master assistant"  
    },  
    {  
      "role": "user",  
      "content": "Generate a strength stat for a warrior character. Apply a +2 racial bonus modifier."  
    }  
  ],  
  "tools": [  
    {  
      "type": "function",  
      "function": {  
        "name": "StatRollAPI",  
        "description": "Generates character stats by rolling 4d6, dropping the lowest die result, and applying a modifier.",  
        "parameters": {  
          "type": "object",  
          "properties": {  
            "modifier": {  
              "description": "An integer representing the modifier to apply to the total of the stat roll.",  
              "type": "integer"  
            }  
          },  
          "required": ["modifier"]  
        }  
      }  
    }  
  ],  
  "reference_answer": {  
    "tool_called": "StatRollAPI",  
    "tool_parameters": {  
      "modifier": 2  
    },  
    "expected_behavior": "Call StatRollAPI with modifier=2 and return the calculated stat value"  
  }  
}
```

## 字段描述



| 字段 | 说明 | 附加说明 | 必需 | 
| --- |--- |--- |--- |
| id | 此 RFT 样本的唯一标识符 | 字符串（例如 sample-001）：用于追踪与去重。 | 否 | 
| 消息 | 定义提示和上下文的聊天消息有序列表 | 对象数组：模型按顺序查看列表。通常而言，列表以系统消息开头，然后是用户。 | 是 | 
| messages[].role | 消息发送方 | 常用值：system、user（其他上下文中也可能出现 assistant） | 否 | 
| messages[].content | 消息文本内容 | 纯字符串：对系统而言，此为指令；对用户而言，此为任务或输入。 | 否 | 
| 工具 | 在本示例中模型可用的工具规范 | 数组：每个项目均定义了工具的界面与元数据。类型可能包括 function 或 internal。 | 否 | 
| reference\$1answer | 本示例的预期模型输出 | 字符串或对象（取决于任务）：作为评测或培训所用的目标。 | 否 | 

**注意**  
任何其他自定义字段（例如 task\$1id、difficulty\$1level、context\$1data）均未经过验证，将作为元数据传递给奖励函数。

## 超参数指导


根据训练方法，建议采用如下超参数：

**常规：**
+ epoch：1
+ 学习率（lr）：1e – 7
+ 生成次数：8
+ 最大新词元数：8192
+ 批处理大小：256

**LoRA（低秩适应）：**
+ LoRA 秩：32

**注意**  
请根据数据集规模和验证性能调整这些值。监控训练指标以防止过拟合。

## 其它属性


将 additionalProperties 设置为 true 后，即可在核心架构要求之外添加自定义字段，从而灵活提供奖励函数正常评测所需的任意数据。

### 常见附加字段


您可以包含以下类型的附加字段：

**元数据：**
+ task\$1id：用于跟踪的唯一标识符
+ difficulty\$1level：问题复杂度指示器
+ domain：主题领域或类别
+ expected\$1reasoning\$1steps：解题过程中的步骤数

**评测标准：**
+ evaluation\$1criteria：具体评分规则
+ custom\$1scoring\$1weights：不同维度的相对权重
+ context\$1data：问题背景信息
+ external\$1references：相关文档或资源链接

### 包含其他属性的示例


以下示例包含自定义元数据字段：

```
{  
  "id": "algebra_001",  
  "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  
}
```

## 数据集规模建议


### 起步要求


建议采用以下最小数据集规模：
+ 至少 100 个训练样本
+ 至少 100 个评测样本

优先使用高质量的输入数据，以及能够在模型响应上一致执行的可靠奖励函数。

### 评测优先的方法


在投入大规模 RFT 训练之前，请先评测模型的基线性能：
+ **性能优异（奖励大于 95%）**：无需进行 RFT，模型表现足够好
+ **性能极差（奖励为 0%）**：先切换到 SFT，建立基本能力
+ **性能中等**：适合采用 RFT 训练

这种“评测优先”的方法可确保奖励函数无缺陷，并判断 RFT 是否适用于自己的使用案例。从小规模数据起步，有助于您熟悉 RFT 工作流程，尽早发现并解决问题，在扩容前验证方案，并测试奖励函数的可靠性。验证通过后，即可扩展到更大规模的数据集，进一步提升模型性能。

## 有效训练数据的特征


### 清晰性与一致性


优质的 RFT 样本需要清晰、无歧义的输入数据，以便能够针对不同的模型输出进行准确的奖励计算。数据中应避免以下干扰：
+ 格式不一致
+ 标签或指令相互矛盾
+ 提示词含义模糊
+ 参考答案互相冲突

任何歧义都会误导训练过程，导致模型学习到非预期的行为。

### 多样性


数据集应覆盖生产环境中的各类使用案例，确保模型在真实环境中表现稳健。包含：
+ 各种问题类型与难度级别
+ 不同的输入格式和边界情况
+ 来自所有预期场景的代表性样本

这种多样性有助于防止过拟合，并确保模型能够妥善处理不熟悉的输入。

### 奖励函数注意事项


设计奖励函数，实现高效训练：
+ 在几秒钟内执行完毕（而非几分钟）
+ 使用 Lambda 实现高效并行
+ 返回一致且可靠的分数
+ 妥善处理不同类型的模型输出

快速且可扩展的奖励函数可支持快速迭代，并在大规模实验中实现高成本效益。

# 监控 RFT 训练


在训练期间监控关键指标，确保有效学习，尽早发现潜在问题。

**Topics**
+ [

## 要跟踪的关键指标
](#nova-hp-rft-monitoring-metrics)
+ [

## RFT 之后的评测
](#nova-hp-rft-monitoring-evaluation)
+ [

## 使用经过微调的模型
](#nova-hp-rft-monitoring-checkpoints)
+ [

## 限制与最佳实践
](#nova-hp-rft-monitoring-limitations)
+ [

## 问题排查
](#nova-hp-rft-monitoring-troubleshooting)

## 要跟踪的关键指标


在训练期间使用 MLflow 监控以下指标：

**奖励指标：**
+ **平均奖励分数**：模型响应的整体质量（应随时间增加）
+ **奖励分布**：获得高、中、低奖励的响应百分比
+ **训练奖励与验证奖励**：通过对比检测过拟合

**训练指标：**
+ **策略更新次数**：成功更新权重的次数
+ **推演完成率**：成功完成评测的样本占比

**异常模式：**
+ 奖励趋于平稳（表明学习效果差）
+ 训练奖励上升，而验证奖励下降（过拟合）
+ 奖励方差随时间显著增大（不稳定）
+ 奖励函数错误率偏高（实现问题）

**何时停止训练：**
+ 已达到目标性能指标
+ 奖励趋于平稳且不再提升
+ 验证性能下降（检测到过拟合）
+ 已达到最大训练预算

## RFT 之后的评测


训练完成后，评测经过微调的模型以判断性能提升情况：
+ **运行 RFT 评测作业**：使用 RFT 训练产出的检查点作为模型
+ **与基线对比**：在相同的测试集上评测基础模型和经过微调的模型
+ **分析指标**：查看任务特定指标（准确率、奖励分数等）
+ **进行定性审查**：人工抽查样本输出质量

有关详细的评测流程，请参阅“评测”一节。

## 使用经过微调的模型


**访问检查点：**

训练完成后，找到检查点：

1. 进入 S3 中的 `output_path`

1. 下载并解压缩 `output.tar.gz`

1. 打开 `manifest.json`

1. 复制 `checkpoint_s3_bucket` 值

**部署用于推理：**

使用检查点 S3 路径进行推理或进一步训练：

```
run:
    model_type: amazon.nova-2-lite-v1:0:256k
    model_name_or_path: "s3://customer-escrow-<account-number>-smtj-<unique-identifier>/<job-name>"
```

有关部署和推理的说明，请参阅“推理”一节。

## 限制与最佳实践


**目前的局限性：**

**Beta 限制：**
+ 需要为 RFT 创建新的 RIG 组。此限制将在正式发布时解决。
+ 实例类型要求：仅支持 P5 实例（至少需要 8x P5.48xlarge）。即将推出：对更小实例类型的支持（预计 2025 年 1 月中旬）。

**功能限制：**
+ 15 分钟 Lambda 超时：奖励函数必须在 15 分钟内完成执行
+ 仅支持单轮对话：不支持多轮对话
+ 验证数据集：训练期间不支持使用。请使用单独的评测作业来评测训练进度。

**训练注意事项：**
+ 低奖励场景：当只有不到 5% 的示例获得正奖励时，训练可能难以进行，此时建议先使用 SFT
+ 数据要求：需具备足够多样性，才能保证学习效果
+ 计算成本：比监督式微调更昂贵

**Nova Forge 消除了以下部分限制：**
+ 支持多轮对话
+ 允许奖励函数超过 15 分钟超时
+ 提供高级算法和调优选项
+ 专为复杂企业使用案例设计，专门针对构建前沿模型进行了调优

**最佳实践：**

**从小规模开始逐步扩展：**
+ 从最小规模数据集（100 – 200 个样本）和少量训练 epoch 开始
+ 在扩大规模之前验证方法
+ 根据结果逐步增加数据集规模和训练步数

**先用 SFT 建立基线：**
+ 如果奖励分数持续偏低（例如始终为 0），应先执行 SFT，再进行 RFT
+ RFT 需要具备合理的基线性能，才能实现有效优化

**设计高效的奖励函数：**
+ 在几秒钟内执行完毕（而非几分钟）
+ 尽量减少外部 API 调用
+ 使用高效的算法与数据结构
+ 实现完善的错误处理机制
+ 训练前进行充分测试
+ 充分利用 Lambda 的并行扩展能力

**主动监控训练：**
+ 跟踪平均奖励分数随时间的变化
+ 观察各样本之间的奖励分布
+ 对比训练奖励与验证奖励
+ 留意异常模式（平稳、过拟合、不稳定）

**根据结果进行迭代：**
+ 如果多次迭代后奖励仍无提升，请调整奖励函数的设计
+ 提升数据集的多样性以提供更清晰的学习信号
+ 如果奖励仍接近零，建议改用 SFT
+ 尝试不同的超参数（学习率、批次大小）

**优化数据质量：**
+ 确保样本多样且具有代表性
+ 包含边界情况和困难样本
+ 验证奖励函数能够对各类样本进行正确评分
+ 移除或修复会干扰奖励函数的样本

## 问题排查


**奖励函数错误：**

症状：训练期间奖励函数调用的错误率较高


| 问题 | 症状 | 解决方案 | 
| --- |--- |--- |
| Lambda 超时 | 15 分钟后频繁超时 | 优化函数性能；对于复杂评测，建议使用 Nova Forge | 
| 并发不足 | Lambda 节流错误 | 提高 lambda\$1concurrency\$1limit 或申请提高配额 | 
| 返回格式无效 | 训练失败并出现格式错误 | 验证返回结构是否符合要求的接口规范 | 
| 未处理的异常 | 间歇性错误 | 添加完善的错误处理与日志记录 | 
| 外部 API 故障 | 评分不一致 | 实现重试逻辑和备用策略 | 

**训练表现不佳：**

症状：奖励没有提升或停留在较低水平

解决方法：
+ **验证奖励函数正确性**：使用已知的优/劣样本进行测试
+ **检查基线性能**：评测基础模型；如果准确率接近零，建议先进行 SFT
+ **提升数据多样性**：添加更多覆盖不同场景的多样化样本
+ **调整超参数**：尝试不同学习率或批次大小
+ **检查奖励信号质量**：确保奖励可区分优劣响应

**过拟合：**

症状：训练奖励上升，而验证奖励下降

解决方法：
+ **减少训练步数**：提前停止训练
+ **扩大数据集规模**：增加训练样本数量
+ **添加正则化**：调整 `weight_decay` 或 `entropy_coeff`
+ **提升数据多样性**：确保训练集代表完整的数据分布

# 评估经过训练的模型
评估

评估配方是一个定义如何执行 Amazon Nova 模型评测任务的 YAML 配置文件。使用此配方，您可以根据常用基准或自有的自定义数据集评估基础模型或训练模型的性能。性能指标可能存储在 Amazon S3 或 TensorBoard 中。评估提供定量指标来帮助您评估模型在各种任务中的性能，从而确定是否需要进一步自定义。

模型评测是一个离线过程，模型使用预定义的答案，按照固定的基准进行测试。模型不是实时评估的，也不是按照用户实时互动进行评估。对于实时评估，您可以在模型部署到 Amazon Bedrock 之后通过调用 Amazon Bedrock 运行时 API 进行评估。

**Topics**
+ [

# 可用的基准测试任务
](customize-fine-tune-evaluate-available-tasks.md)
+ [

# 了解配方参数
](customize-fine-tune-evaluate-understand-modify.md)
+ [

# 评估配方示例
](customize-fine-tune-evaluate-recipe-examples.md)
+ [

# 启动评估作业
](customize-fine-tune-evaluate-start-job.md)
+ [

# 访问和分析评估结果
](customize-fine-tune-evaluate-access-results.md)
+ [

# RFT 评测
](nova-hp-evaluate-rft.md)

# 可用的基准测试任务


一个可用的示例代码包，用于演示如何使用适用于 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 | 文本 | 高级推理任务：一系列具有挑战性的问题，用于考核更高级别的认知和解决问题的能力。 | 准确性 | zs\$1cot | 是 | 
| gpqa | 文本 | 一般物理问题解答：评测对物理概念和相关问题解决能力的理解情况。 | 准确性 | zs\$1cot | 否 | 
| math | 文本 | 数学问题解决：衡量在代数、微积分及应用题等领域的数学推理能力。 | exact\$1match | zs\$1cot | 是 | 
| strong\$1reject | 文本 | 质量控制任务：测试模型检测和拒绝不当、有害或不正确内容的能力。 | deflection | zs | 是 | 
| IFEval | 文本 | 指令跟随评估：衡量模型遵循给定指令并按照规范完成任务的准确程度。 | 准确性 | zs | 否 | 
| gen\$1qa | 文本 | 自定义数据集评估：让您可以自带数据集进行基准测试，将模型输出与参考答案及 ROUGE 和 BLEU 等指标进行比较。 | 全部 | gen\$1qa | 否 | 
| llm\$1judge | 文本 | LLM-as-a-judge 偏好比较：使用 Amazon Nova Judge 模型来确定提示的成对响应之间的偏好（B 与 A 比较），计算 B 比 A 更受欢迎的概率。 | 全部 | judge | 否 | 
| humaneval | 文本 | HumanEval：一个基准测试数据集，旨在评估大型语言模型的代码生成能力 | pass@1 | zs | 否 | 
|  mm\$1llm\$1judge  |  多模态（图像）  |  该全新基准评测的运行方式与上述基于文本的 `llm_judge` 一致。唯一区别在于其支持图像推理。  |  全部  |  judge  |  否  | 
|  rubric\$1llm\$1judge  | Text |  Rubric Judge 是基于 Amazon 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  | Text |  AIME 2024：2024 年美国数学邀请赛（American Invitational Mathematics Examination），用于考查高阶数学推理与问题求解能力  |  exact\$1match  |  zs\$1cot  | No | 
|  calendar\$1scheduling  | Text |  Natural Plan：日程规划任务，用于评估跨日期、跨人员的会议安排等规划能力  |  exact\$1match  |  fs  | No | 

以下 `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` 子任务可用：

```
MATH_SUBTASKS = [
    "algebra",
    "counting_and_probability",
    "geometry",
    "intermediate_algebra",
    "number_theory",
    "prealgebra",
    "precalculus",
]
```

# 了解配方参数


**运行配置**  
以下是常规运行配置和所涉及参数的说明。

```
run:
  name: eval_job_name
  model_type: amazon.nova-micro-v1:0:128k
  model_name_or_path: nova-micro/prod
  replicas: 1
  data_s3_path: ""
  output_s3_path: s3://output_path
  mlflow_tracking_uri: ""
  mlflow_experiment_name : ""
  mlflow_run_name : ""
```
+ `name`：（必填）评估作业的描述性名称。这有助于在 AWS 管理控制台中识别您的作业。
+ `model_type`：（必填）指定要使用的 Amazon 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://<escrow bucket>/<job id>/outputs/checkpoints`
+ `replicas`：（必填）要在分布式训练中使用的计算实例数。您必须将此值设置为 1，因为不支持多节点。
+ `data_s3_path`：（必填）输入数据集的 S3 路径。除非您使用*自带数据集*或 *LLM-as-a-Judge* 配方，否则请将此参数留空。
+ `output_s3_path`：（必填）存储输出评估构件的 S3 路径。请注意，输出 S3 存储桶必须由创建作业的账户创建。
+ `mlflow_tracking_uri`:（可选）用于跟踪 MLflow 运行/实验的 MLflow 跟踪服务器 ARN。确保您拥有通过 SageMaker AI 执行角色访问跟踪服务器的权限

**评估配置**  
以下是模型评测配置和所涉及参数的说明。

```
evaluation:
  task: mmlu
  strategy: zs_cot
  subtask: mathematics
  metric: accuracy
```
+ `task`：（必填）指定要使用的评估基准测试或任务。

  支持的任务列表：
  + mmlu
  + mmlu\$1pro
  + bbh
  + gpqa
  + math
  + strong\$1reject
  + gen\$1qa
  + ifeval
  + llm\$1judge
  + humaneval
  + mm\$1llm\$1judge
  + rubric\$1llm\$1judge
  + aime\$12024
  + calendar\$1scheduling
  + humaneval
+ `strategy`：（必填）定义评估方法：
  + zs\$1cot：零样本思维链，该提示方法激励大型语言模型逐步进行推理，而不提供明确的示例。
  + zs：零样本，该方法事先无需任何训练示例即可解决问题。
  + gen\$1qa：一种专门用于自带数据集配方的策略。
  + judge：一种专门用于 Amazon Nova LLM as judge 和 mm\$1llm\$1judge 的策略。
+ `subtask`：（可选且可移除）为某些评估任务指定具体的子任务。如果您的任务没有任何子任务，请将其从配方中移除。
+ `metric`：（必填）要使用的评估指标。
  + accuracy：正确答案的百分比
  + exact\$1match：（对于 `math` 基准测试），返回输入预测字符串与其引用完全匹配的速率。
  + deflection：（对于 `strong reject` 基准测试），返回基本模型的相对偏差和差异显著性指标。
  + pass@1：（对于 `humaneval` 基准测试），该指标用于衡量模型的最高置信度预测与正确答案相匹配的情况所占的百分比。
  + `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` 的获胜次数。
      + `b_scores_stderr`：成对判断中 `response_B scores` 的标准误差。
      + `ties`：`response_A` 和 `response_B` 被评估为相等的判断数量。
      + `ties_stderr`：成对判断中平局的标准误差。
      + `inference_error`：无法适当评估的判断数量。
      + `inference_error_stderr`：判断中推理错误的标准误差。
      + `score`：基于 `response_B` 在前向和反向传递中的获胜次数得出的总分。
      + `score_stderr`：成对判断中总分的标准误差。
      + `winrate`：使用 Bradley-Terry 概率模型计算的 response\$1B 比 response\$1A 更受欢迎的概率。
      + `lower_rate`：自动采样预估胜率的下限（第 2.5 百分位）。

**推理配置**  
以下是推理配置和所涉及参数的说明。所有参数都是可选的。

```
inference:
  max_new_tokens: 200
  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`：要生成的最大词元数。必须是整数。
+ `top_k`：要考虑的最高概率词元的数量。必须是整数。
+ `top_p`：词元采样的累积概率阈值。此值必须是介于 0.0 到 1.0 之间的浮点数（含两端值）。
+ `temperature`：词元选择的随机性。值越大，随机性越大。使用 0 以使结果具有确定性。此值必须是最小值为 0 的浮点数。
+ `top_logprobs`：推理响应中需返回的最高对数概率数量。取值必须为 0 到 20 之间的整数。对数概率包含消息内容中返回的输出词元及其对应的对数概率值。
+ `reasoning_effort`：控制具备推理能力模型的推理行为。仅当 `model_type` 指定了具备推理能力的模型（当前为 `amazon.nova-2-lite-v1:0:256k`）时，才需设置 `reasoning_effort`。可用选项为 `null`（未设置时的默认值；表示禁用推理）、`low` 或 `high`。

请注意，对于 `humaneval`，建议使用以下推理配置：

```
inference:
  top_k: 1
  max_new_tokens: 1600
  temperature: 0.0
```

**MLflow 配置**  
以下是 MLflow 配置和所涉及参数的说明。所有参数都是可选的。

```
run:
  mlflow_tracking_uri: ""
  mlflow_experiment_name: ""
  mlflow_run_name: ""
```
+ `mlflow_tracking_uri`:（可选）MLflow 跟踪服务器地址（仅在 SMHP 下需要）
+ `mlflow_experiment_name`:（可选）实验名称，用于对相关的机器学习运行记录进行分组
+ `mlflow_run_name`:（可选）实验中某次特定训练运行的自定义名称

# 评估配方示例


Amazon Nova 提供了四种类型的评估配方，这些配方可在 SageMaker HyperPod 配方 GitHub 存储库中找到。

## 通用文本基准测试配方


这些配方让您能够通过一套全面的纯文本基准测试来评估 Amazon Nova 模型的基本功能。它们以 `xxx_general_text_benchmark_eval.yaml` 格式提供。

## 自带数据集基准测试配方


这些配方让您能够使用自己的数据集进行基准测试，并使用不同类型的指标将模型输出与参考答案进行对比。它们以 `xxx_bring_your_own_dataset_eval.yaml` 格式提供。

以下是自带数据集的要求：
+ 文件格式要求
  + 必须有一个包含评估示例的 `gen_qa.jsonl` 文件。
  + 您的数据集必须上传到 SageMaker 训练作业可以访问的 S3 位置。
  + 该文件必须遵循常规问答数据集所需的架构格式。
+ 架构格式要求：JSONL 文件中的每一行都必须是包含以下字段的 JSON 对象：
  + `query`：（必填）包含需要答案的问题或说明的字符串
  + `response`：（必填）包含预期模型输出的字符串
  + `system`：（可选）包含系统提示的字符串，用于在处理查询之前设置 AI 模型的行为、角色或个性
  + `metadata`：（可选）字符串类型，与本条记录关联的元数据，用于标签分类。

以下是自带数据集示例条目

```
{
   "system":"You are a 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 that 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 that follows 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"
}
```

要使用您的自定义数据集，请按以下必填字段修改您的评估配方，且不要更改其中任何内容：

```
evaluation:
  task: gen_qa
  strategy: gen_qa
  metric: all
```

适用以下限制：
+ 每次评估只支持一个 JSONL 文件。
+ 该文件必须严格遵循定义的架构。
+ 上下文长度限制：对于数据集中的每个样本，上下文长度（包括系统 \$1 查询提示）应小于 3.5k。

## Nova LLM-as-a-Judge 基准测试配方


Amazon Nova LLM-as-a-Judge 是一项模型评测特征，让客户可以使用自定义数据集，将一个模型的响应质量与基准模型的响应质量进行比较。其接受包含提示、基线响应和挑战响应的数据集，然后使用 Amazon Nova Judge 模型基于 [Bradley-Terry 概率](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model)和成对比较提供胜率指标。

配方以 `xxx_llm_judge_eval.yaml` 格式提供。

以下是 LLM-as-a-Judge 的要求：
+ 文件格式要求
  + 有一个包含评估示例的 `llm_judge.jsonl` 文件。文件名称必须为 `llm_judge.jsonl`。
  + 您的数据集必须上传到 [SageMaker AI SageMaker HyperPod RIG](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-hp-cluster.html) 可以访问的 S3 位置。
  + 该文件必须遵循 `llm_judge.jsonl` 数据集所需的架构格式。
  + 输入数据集应确保所有记录的上下文长度小于 12k。
+ 架构格式要求：JSONL 文件中的每一行都必须是包含以下字段的 JSON 对象：
  + `prompt`：（必填）包含生成响应提示的字符串。
  + `response_A`：包含基准响应的字符串。
  + `response_B`：包含与基准响应进行比较的替代响应的字符串。

这是一个 LLM-as-a-Judge 示例条目

```
{
"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 文件。
+ 该文件必须严格遵循定义的架构。
+ Amazon Nova Judge 模型对于所有模型系列规格（即 Lite、Micro 和 Pro）都是一样的。
+ 目前不支持自定义评估模型。
+ 上下文长度限制：对于数据集中的每个样本，上下文长度（包括系统 \$1 查询提示）应小于 7k。

## 使用 Nova LLM-as-a-judge，完成多模态（图像）基准测试配方


Nova LLM Judge 多模态（图像）版（简称 Amazon Nova MM\$1LLM Judge）是一项模型评测功能，支持使用自定义数据集，将目标模型的响应质量与基线模型的响应进行对比评测。该功能接受包含提示、基线响应和挑战响应的数据集，以及 Base64 编码字符串图像，然后使用 Amazon 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 训练作业可以访问的 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 in echo 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 Lite 规格是一样的。
+ 目前不支持自定义评估模型。
+ 不支持 Amazon S3 图像 URI。
+ 输入数据集应确保：排除 image 属性后，所有记录的上下文长度均小于 12k。

## Rubric Judge


Rubric Judge 是基于 Amazon Nova 2.0 Lite 构建的增强版 LLM-as-a-judge 评测模型。与仅提供偏好判定（A 优于 B、B 优于 A 或平局）的[原始评判模型](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/)不同，Rubric Judge 可针对每个提示词动态生成自定义评估准则，并在多个维度上给出细粒度评分。

关键功能：
+ **动态评估维度生成**：根据输入提示自动生成相关的评估维度
+ **加权评分**：为各评估维度分配重要性权重，体现其相对优先级
+ **细粒度评测**：对每个维度以二分类（是/否）或量表（1–5 分）形式给出详细评分
+ **质量指标**：计算连续型质量得分（0–1 区间），量化不同响应之间的差异程度

模型生成的评估维度示例：

```
price_validation:
  description: "The response includes validation to ensure price is a positive value."
  type: "scale"
  weight: 0.3
```

模型会依据所有生成的评估维度对两组响应进行评估，再利用各维度得分得出最终偏好判定。

**Topics**
+ [

### 配方配置
](#nova-hp-evaluate-rubric-judge-recipe)
+ [

### 输入数据集格式
](#nova-hp-evaluate-rubric-judge-input)
+ [

### 评估输出
](#nova-hp-evaluate-rubric-judge-output)
+ [

### 推理模型支持
](#nova-hp-evaluate-rubric-judge-reasoning)

### 配方配置


**Rubric Judge 配方**  
在配方中通过设置 `task: rubric_llm_judge` 来启用 Rubric Judge：

```
run:
  name: nova-eval-job-name                              # [MODIFIABLE] Unique identifier for your evaluation job
  model_type: amazon.nova-2-lite-v1:0:256k              # [FIXED] Rubric Judge model type
  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: ""                                      # [FIXED] Leave empty for SageMaker Training job
  output_s3_path: ""                                    # [FIXED] Leave empty for SageMaker Training job

evaluation:
  task: rubric_llm_judge                                # [FIXED] Evaluation task - enables Rubric Judge
  strategy: judge                                       # [FIXED] Evaluation strategy
  metric: all                                           # [FIXED] Metric calculation method

inference:
  max_new_tokens: 12000                                 # [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)
```

**原始 LLM-as-a-judge 配方（供比较）**  
原始评判模型使用 `task: llm_judge`：

```
run:
  name: eval-job-name                                   # [MODIFIABLE] Unique identifier for your evaluation job
  model_type: amazon.nova-micro-v1:0:128k               # [FIXED] Model type
  model_name_or_path: "nova-micro/prod"                 # [FIXED] Path to model checkpoint or identifier
  replicas: 1                                           # [MODIFIABLE] Number of replicas for SageMaker Training job
  data_s3_path: ""                                      # [FIXED] Leave empty for SageMaker Training job
  output_s3_path: ""                                    # [FIXED] Leave empty for SageMaker Training job

evaluation:
  task: llm_judge                                       # [FIXED] Original judge task
  strategy: judge                                       # [FIXED] Evaluation strategy
  metric: all                                           # [FIXED] Metric calculation method

inference:
  max_new_tokens: 12000                                 # [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)
```

### 输入数据集格式


输入数据集格式与[原始评判模型](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/)完全一致：

**必填字段：**
+ `prompt`：字符串类型，包含输入提示与指令
+ `response_A`：字符串类型，基准模型的输出
+ `response_B`：字符串类型，自定义模型的输出

**示例数据集（JSONL 格式）：**

```
{"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."}
```

**格式要求：**
+ 每条记录必须是单行 JSON 对象
+ 各行记录以换行符分隔
+ 严格遵循示例中所示的字段命名规则

### 评估输出


**输出结构**  
与原始评判模型相比，Rubric Judge 可生成更完善的评估指标：

```
{
  "config_general": {
    "lighteval_sha": "string",
    "num_fewshot_seeds": "int",
    "max_samples": "int | null",
    "job_id": "int",
    "start_time": "float",
    "end_time": "float",
    "total_evaluation_time_secondes": "string",
    "model_name": "string",
    "model_sha": "string",
    "model_dtype": "string | null",
    "model_size": "string"
  },
  "results": {
    "custom|rubric_llm_judge_judge|0": {
      "a_scores": "float",
      "a_scores_stderr": "float",
      "b_scores": "float",
      "b_scores_stderr": "float",
      "ties": "float",
      "ties_stderr": "float",
      "inference_error": "float",
      "inference_error_stderr": "float",
      "score": "float",
      "score_stderr": "float",
      "weighted_score_A": "float",
      "weighted_score_A_stderr": "float",
      "weighted_score_B": "float",
      "weighted_score_B_stderr": "float",
      "score_margin": "float",
      "score_margin_stderr": "float",
      "winrate": "float",
      "lower_rate": "float",
      "upper_rate": "float"
    }
  },
  "versions": {
    "custom|rubric_llm_judge_judge|0": "int"
  }
}
```

**Rubric Judge 新增指标**  
以下六项指标为 Rubric Judge 独有，可提供细粒度的质量评测：


| 指标 | 说明 | 
| --- |--- |
| weighted\$1score\$1A | 基于模型生成的所有评估维度，对 response\$1A 计算的归一化加权平均质量得分。得分按维度重要性加权，并归一化到 0–1 区间（分值越高，质量越好） | 
| weighted\$1score\$1A\$1stderr | weighted\$1score\$1A 的均值标准误，用于表示统计不确定性 | 
| weighted\$1score\$1B | 基于模型生成的所有评估维度，对 response\$1B 计算的归一化加权平均质量得分。得分按维度重要性加权，并归一化到 0–1 区间（分值越高，质量越好） | 
| weighted\$1score\$1B\$1stderr | weighted\$1score\$1B 的均值标准误，用于表示统计不确定性 | 
| score\$1margin | 加权分数差值（计算公式：weighted\$1score\$1A - weighted\$1score\$1B）。范围：-1.0 至 1.0。正值表示 response\$1A 更优；负值表示 response\$1B 更优；接近 0 表示两者质量相近 | 
| score\$1margin\$1stderr | score\$1margin 的均值标准误，用于表示质量差异测量结果的不确定性 | 

**加权分数指标说明**  
**用途**：加权分数提供连续型质量评估，作为二分类偏好判定的补充，便于更深入地分析模型性能。

**与原始评判模型的主要区别**：
+ **原始评判模型**：仅输出离散偏好结果（A 优于 B、B 优于 A、A 与 B 持平）
+ **Rubric Judge**：基于自定义评估维度，同时输出偏好结果与连续型质量得分（0–1 区间）

**score\$1margin 解读**：
+ `score_margin = -0.128`：表示 response\$1B 得分比 response\$1A 高 12.8 个百分点
+ `|score_margin| < 0.1`：质量差异极小（判定接近）
+ `|score_margin| > 0.2`：质量差异明显（判定置信度高）

**使用案例**：
+ **模型优化**：定位模型表现不足的具体方面
+ **质量量化**：不仅评估胜负关系，更衡量性能差距的大小
+ **置信度评测**：区分接近判定与明确的质量差异

**重要**  
最终判定仍以评判模型的显式偏好标签为准，以保留整体推理能力，并通过正向/反向评估有效缓解位置偏差。加权分数仅作为可观测性工具，不能替代主判定结果。

**计算方法**  
加权分数通过以下流程计算：
+ **提取评估维度数据**：解析评判模型的 YAML 输出，提取各维度得分与权重
+ **得分归一化**：
  + 量表型维度（1–5 分）：通过公式 `(score - 1) / 4` 归一化到 0–1 区间
  + 二分型维度（是/否）：转换为 1.0/0.0
+ **应用权重**：将每条归一化得分乘以对应维度的权重
+ **汇总得分**：对每条响应的所有加权分数求和
+ **计算差值**：计算 `score_margin = weighted_score_A - weighted_score_B`

**示例**：如果若 response\$1A 加权总分为 0.65，response\$1B 为 0.78，则 `score_margin` = -0.13，表示在所有加权维度下，response\$1B 的质量高出 13 个百分点。

### 推理模型支持


推理模型支持功能可借助具备推理能力的 Amazon Nova 模型开展评测，这类模型会在生成最终响应前执行显式的内部推理。该功能通过 `reasoning_effort` 参数实现 API 级别的控制，可动态启用/禁用推理功能，有助于提升复杂分析类任务的响应质量。

**支持的模型**：
+ amazon.nova-2-lite-v1:0:256k

**配方配置**  
在配方的 `inference` 模块中添加 `reasoning_effort` 参数，即可启用推理功能：

```
run:
  name: 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  SageMaker HyperPod  job
  output_s3_path: ""                                     # [MODIFIABLE] Output path for SageMaker  SageMaker HyperPod  job (not compatible with SageMaker Training jobs)

evaluation:
  task: mmlu                                             # [MODIFIABLE] Evaluation task
  strategy: generate                                     # [MODIFIABLE] Evaluation strategy
  metric: all                                            # [MODIFIABLE] Metric calculation method

inference:
  reasoning_effort: high                                 # [MODIFIABLE] Enables reasoning mode; options: low/medium/high or null to disable
  max_new_tokens: 200                                    # [MODIFIABLE] Maximum tokens to generate
  top_k: 50                                              # [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 | 启用推理且无约束 | 内部推理无词元上限 | 需要深度分析与分步推理的复杂问题 | 

**何时启用推理**  
**满足以下场景时，建议使用推理模式（`low`、`medium` 或 `high`）**：
+ 复杂问题求解任务（数学、逻辑谜题、编程）
+ 需要中间推理过程的多步分析类问题
+ 详细推导或分步思考可提升准确率的任务
+ 优先保证响应质量而非速度的场景

**满足以下场景时，建议使用非推理模式（不设置该参数）**：
+ 简单问答或事实查询
+ 创意写作类任务
+ 对响应速度要求极高的场景
+ 需要排除推理开销的性能基准测试
+ 推理无法提升效果、需优化成本的场景

**问题排查**  
**错误：“Reasoning mode is enabled but model does not support reasoning”**

**原因**：`reasoning_effort` 参数被设为非空值，但指定的 `model_type` 支持推理。

**解决方法：**
+ 确认模型类型为 `amazon.nova-2-lite-v1:0:256k`
+ 若使用其他模型，或切换为具备推理能力的模型，或从配方中移除 `reasoning_effort` 参数

# 启动评估作业


下面提供了建议的评估实例类型和模型类型配置：

```
# Install Dependencies (Helm - https://helm.sh/docs/intro/install/)
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
rm -f ./get_helm.sh

# Install the SageMaker HyperPod CLI
git clone --recurse-submodules https://github.com/aws/sagemaker-hyperpod-cli.git
git checkout -b release_v2
cd sagemaker-hyperpod-cli
pip install .

# Verify the installation
hyperpod --help

# Connect to a SageMaker HyperPod Cluster
hyperpod connect-cluster --cluster-name cluster-name


# Submit the Job using the recipe for eval
# Namespace by default should be kubeflow
hyperpod start-job [--namespace namespace] --recipe evaluation/nova/nova_micro_p5_48xl_general_text_benchmark_eval --override-parameters \
'{
    "instance_type":"p5d.48xlarge",
    "container": "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-HP-Eval-V2-latest",
    "recipes.run.name": custom-run-name,
    "recipes.run.model_type": model_type,
    "recipes.run.model_name_or_path" " model name or finetune checkpoint s3uri,
    "recipes.run.data_s3_path": s3 for input data only for genqa and llm_judge, must be full S3 path that include filename,
}'

# List jobs
hyperpod list-jobs [--namespace namespace] [--all-namespaces]

# Getting Job details
hyperpod get-job --job-name job-name [--namespace namespace] [--verbose]

# Listing Pods
hyperpod list-pods --job-name job-name --namespace namespace

# Cancel Job
hyperpod cancel-job --job-name job-name [--namespace namespace]
```

您还应该能够通过 Amazon EKS 集群控制台查看作业状态。

# 访问和分析评估结果


成功完成评估作业后，您可以参考本节中的信息访问并分析结果。根据配方中定义的 `output_s3_path`（例如 `s3://output_path/`），输出结构如下所示：

```
job_name/
├── eval-result/
│    └── results_[timestamp].json
│    └── inference_output.jsonl (only present for gen_qa)
│    └── details/
│        └── model/
│            └── execution-date-time/
│                └──details_task_name_#_datetime.parquet
└── tensorboard-results/
    └── eval/
        └── events.out.tfevents.[timestamp]
```

指标结果存储在指定的 S3 输出位置 `s3://output_path/job_name/eval-result/result-timestamp.json`。

Tensorboard 结果存储在 S3 路径 `s3://output_path/job_name/eval-tensorboard-result/eval/event.out.tfevents.epoch+ip` 中。

除 `llm_judge` 和 `strong_reject` 之外的所有推理输出都存储在 S3 路径中：`s3://output_path/job_name/eval-result/details/model/taskname.parquet`。

对于 `gen_qa`，`inference_output.jsonl` 文件针对每个 JSON 对象均包含以下字段：
+ prompt：提交给模型的最终提示
+ 推理：模型的原始推理输出
+ gold：来自输入数据集的目标响应
+ metadata：来自输入数据集的元数据字符串（如果提供）

要在 Tensorboard 中直观显示您的评估指标，请完成以下步骤：

1. 导航到 SageMaker AI Tensorboard。

1. 选择 **S3 文件夹**。

1. 添加您的 S3 文件夹路径，例如 `s3://output_path/job-name/eval-tensorboard-result/eval`。

1. 等待同步完成。

时间序列、标量和文本可视化均可用。

我们建议您遵循以下最佳实操：
+ 按模型和基准测试类型整理输出路径。
+ 保持一致的命名约定以便于跟踪。
+ 将解压缩的结果保存在安全的位置。
+ 监控 TensorBoard 同步状态以成功加载数据。

您可以在 CloudWatch 日志组 `/aws/sagemaker/Clusters/cluster-id` 中找到 SageMaker HyperPod 作业错误日志。

## 对数概率输出格式


在推理设置中配置 `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` 则提供可读形式。

# RFT 评测


**注意**  
仅当您为 Amazon Nova Forge 客户时，方可在自有 AWS 环境中通过远程奖励函数开展评测。

**重要**  
`rl_env` 配置字段仅用于评测，不用于训练。训练期间，需要使用 `reward_lambda_arn`（单轮）或带有 `rollout.delegate: true`（多轮）的 BYOO 基础设施来配置奖励函数。

**什么是 RFT 评测？**  
RFT 评测支持您在强化学习微调的训练前、训练中及训练后，通过自定义奖励函数评测模型性能。与采用预定义指标的标准评测不同，RFT 评测支持通过 Lambda 函数自定义成功标准，并依据您的具体需求对模型输出进行评分。

**为什么要使用 RFT 进行评测？**  
评测对于判断强化微调过程是否实现以下目标至关重要：
+ 提升模型与您特定使用案例及人类价值偏好的对齐程度
+ 维持或提升模型在核心任务上的能力
+ 避免产生非预期副作用，例如事实准确性下降、内容冗余度增加或其他任务性能退化
+ 满足由奖励函数定义的自定义成功标准

**何时使用 RFT 评测**  
在以下场景中使用 RFT 评测：
+ RFT 训练之前：在评测数据集上建立基线指标
+ RFT 训练期间：使用中间检查点监控训练进度
+ RFT 训练之后：验证最终模型是否符合您的要求
+ 模型对比：采用一致的奖励标准对多个模型版本进行评测

**注意**  
如需领域专属的自定义评估指标，请使用 RFT 评测。对于通用评测（准确率、困惑度、BLEU），请使用标准评测方法。

**Topics**
+ [

## 数据格式要求
](#nova-hp-evaluate-rft-data-format)
+ [

## 准备评测配方
](#nova-hp-evaluate-rft-recipe)
+ [

## 预设奖励函数
](#nova-hp-evaluate-rft-preset)
+ [

## 创建奖励函数
](#nova-hp-evaluate-rft-create-function)
+ [

## IAM 权限
](#nova-hp-evaluate-rft-iam)
+ [

## 执行评测作业
](#nova-hp-evaluate-rft-execution)
+ [

## 了解评测结果
](#nova-hp-evaluate-rft-results)

## 数据格式要求


**输入数据结构**  
RFT 评测输入数据必须遵循 OpenAI 强化微调格式。每个样本都是一个 JSON 对象，其中包含：
+ `messages`：包含 `system` 和 `user` 角色的对话轮次数组
+ 其他可选元数据，例如 reference\$1answer

**数据格式示例**  
以下示例显示了所需格式：

```
{
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "Solve for x. Return only JSON like {\"x\": <number>}. Equation: 2x + 5 = 13"
        }
      ]
    }
  ],
  "reference_answer": {
    "x": 4
  }
}
```

**目前的局限性**  
以下限制适用于 RFT 评测：
+ 纯文本模式：不支持多模态输入（图像、音频、视频）
+ 单轮对话：仅支持单条用户消息（不支持多轮对话）
+ JSON 格式：输入数据必须为 JSONL 格式（每行一个 JSON 对象）
+ 模型输出：根据指定模型生成的补全进行评测

## 准备评测配方


**示例配方配置**  
以下示例展示了一个完整的 RFT 评测配方：

```
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  SageMaker HyperPod  jobs
  data_s3_path: ""                                        # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs
  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: 8196                                    # [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

# Evaluation Environment Configuration (NOT used in training)
rl_env:
  reward_lambda_arn: arn:aws:lambda:<region>:<account_id>:function:<reward-function-name>
```

## 预设奖励函数


两个预设的奖励函数（`prime_code` 和 `prime_math`）可用作 Lambda 层，以便与 RFT Lambda 函数集成。

**概述**  
这些预设函数提供开箱即用的评测能力，适用于：
+ **prime\$1code**：代码生成和正确性评测
+ **prime\$1math**：数学推理和问题求解评测

**快速设置**  
要使用预设奖励函数，请执行以下操作：

1. 从 [nova-custom-eval-sdk 版本](https://github.com/aws/nova-custom-eval-sdk/releases)页面下载 Lambda 层

1. 使用 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、纯文本、符号）
+ 数学等价性检查
+ 表达式归一化与化简

**最佳实践**  
使用预设奖励函数时，请遵循以下最佳实践：
+ 在测试用例中使用正确的数据类型（整数与字符串、布尔值与 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 函数接收批量的模型输出并返回奖励分数。以下是一个实现示例：

```
from typing import List, Any
import json
import re
from dataclasses import asdict, dataclass


@dataclass
class MetricResult:
    """Individual metric result."""
    name: str
    value: float
    type: str


@dataclass
class RewardOutput:
    """Reward service output."""
    id: str
    aggregate_reward_score: float
    metrics_list: List[MetricResult]


def lambda_handler(event, context):
    """ Main lambda handler """
    return lambda_grader(event)


def lambda_grader(samples: list[dict]) -> list[dict]:
    """ Core grader function """
    scores: List[RewardOutput] = []

    for sample in samples:
        print("Sample: ", json.dumps(sample, indent=2))

        # Extract components
        idx = sample.get("id", "no id")
        if not idx or idx == "no id":
            print(f"ID is None/empty for sample: {sample}")

        ground_truth = sample.get("reference_answer")

        if "messages" not in sample:
            print(f"Messages is None/empty for id: {idx}")
            continue

        if ground_truth is None:
            print(f"No answer found in ground truth for id: {idx}")
            continue

        # Get model's response (last turn is assistant turn)
        last_message = sample["messages"][-1]

        if last_message["role"] != "nova_assistant":
            print(f"Last message is not from assistant for id: {idx}")
            continue

        if "content" not in last_message:
            print(f"Completion text is empty for id: {idx}")
            continue

        model_text = last_message["content"]

        # --- Actual scoring logic (lexical overlap) ---
        ground_truth_text = _extract_ground_truth_text(ground_truth)

        # Calculate main score and individual metrics
        overlap_score = _lexical_overlap_score(model_text, ground_truth_text)

        # Create two separate metrics as in the first implementation
        accuracy_score = overlap_score  # Use overlap as accuracy
        fluency_score = _calculate_fluency(model_text)  # New function for fluency

        # Create individual metrics
        metrics_list = [
            MetricResult(name="accuracy", value=accuracy_score, type="Metric"),
            MetricResult(name="fluency", value=fluency_score, type="Reward")
        ]

        ro = RewardOutput(
            id=idx,
            aggregate_reward_score=overlap_score,
            metrics_list=metrics_list
        )

        print(f"Response for id: {idx} is {ro}")
        scores.append(ro)

    # Convert to dict format
    result = []
    for score in scores:
        result.append({
            "id": score.id,
            "aggregate_reward_score": score.aggregate_reward_score,
            "metrics_list": [asdict(metric) for metric in score.metrics_list]
        })

    return result


def _extract_ground_truth_text(ground_truth: Any) -> str:
    """
    Turn the `ground_truth` field into a plain string.
    """
    if isinstance(ground_truth, str):
        return ground_truth

    if isinstance(ground_truth, dict):
        # Common patterns: { "explanation": "...", "answer": "..." }
        if "explanation" in ground_truth and isinstance(ground_truth["explanation"], str):
            return ground_truth["explanation"]
        if "answer" in ground_truth and isinstance(ground_truth["answer"], str):
            return ground_truth["answer"]
        # Fallback: stringify the whole dict
        return json.dumps(ground_truth, ensure_ascii=False)

    # Fallback: stringify anything else
    return str(ground_truth)


def _tokenize(text: str) -> List[str]:
    # Very simple tokenizer: lowercase + alphanumeric word chunks
    return re.findall(r"\w+", text.lower())


def _lexical_overlap_score(model_text: str, ground_truth_text: str) -> float:
    """
    Simple lexical overlap score in [0, 1]:
      score = |tokens(model) ∩ tokens(gt)| / |tokens(gt)|
    """
    gt_tokens = _tokenize(ground_truth_text)
    model_tokens = _tokenize(model_text)

    if not gt_tokens:
        return 0.0

    gt_set = set(gt_tokens)
    model_set = set(model_tokens)
    common = gt_set & model_set

    return len(common) / len(gt_set)


def _calculate_fluency(text: str) -> float:
    """
    Calculate a simple fluency score based on:
    - Average word length
    - Text length
    - Sentence structure

    Returns a score between 0 and 1.
    """
    # Simple implementation - could be enhanced with more sophisticated NLP
    words = _tokenize(text)

    if not words:
        return 0.0

    # Average word length normalized to [0,1] range
    # Assumption: average English word is ~5 chars, so normalize around that
    avg_word_len = sum(len(word) for word in words) / len(words)
    word_len_score = min(avg_word_len / 10, 1.0)

    # Text length score - favor reasonable length responses
    ideal_length = 100  # words
    length_score = min(len(words) / ideal_length, 1.0)

    # Simple sentence structure check (periods, question marks, etc.)
    sentence_count = len(re.findall(r'[.!?]+', text)) + 1
    sentence_ratio = min(sentence_count / (len(words) / 15), 1.0)

    # Combine scores
    fluency_score = (word_len_score + length_score + sentence_ratio) / 3

    return fluency_score
```

**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 in the traditional sense. However, the development and deployment of AI systems like me involve extensive security measures, including data encryption, user privacy protection, and other safeguards to ensure safe and responsible use."
          }
        ]
      }
    ],
    "reference_answer": {
      "compliant": "No",
      "explanation": "As an AI developed by Company, I do not have a traditional security team. However, the deployment involves stringent safety measures, such as encryption and privacy safeguards."
    }
  }
]
```

**注意**  
消息结构包含嵌套的 `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 AI 执行角色必须具有调用 Lambda 函数的权限。将此策略添加到 SageMaker AI 执行角色：

```
{
  "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 服务（例如用于参考数据的 Amazon S3、用于日志记录的 DynamoDB），请将这些权限添加到 Lambda 执行角色。

## 执行评测作业


1. **准备数据**
   + 根据数据格式要求对评测数据进行格式化
   + 将 JSONL 文件上传到 Amazon 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. **运行评测**

   使用提供的笔记本执行评测作业：[Nova 模型评测笔记本](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook)

1. **监控进度**

   通过以下方式监控评测作业：
   + SageMaker AI 控制台：检查作业状态与日志
   + CloudWatch Logs：查看详细执行日志
   + Lambda 日志：调试奖励函数相关问题

## 了解评测结果


**输出格式**  
评测作业会以 JSONL 格式将结果输出到指定的 Amazon 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 | 较差 | 检查训练数据和奖励函数 | 

**重要**  
以上仅为通用准则。请根据业务需求、基线模型性能、领域特定约束以及进一步训练的成本效益分析，自行定义阈值。

# 使用 MLflow 监控 HyperPod
MLflow 监控

您可借助 MLflow 跟踪并监控 SageMaker HyperPod 上的训练作业。请按如下步骤搭建 MLflow，并将其接入训练配方。

***创建 MLflow 应用程序***

AWS CLI 命令示例

```
aws sagemaker-mlflow create-mlflow-app \
    --name <app-name> \
    --artifact-store-uri <s3-bucket-name> \
    --role-arn <role-arn> \
    --region <region-name>
```

示例输出

```
{
    "Arn": "arn:aws:sagemaker:us-east-1:111122223333:mlflow-app/app-LGZEOZ2UY4NZ"
}
```

***生成预签名 URL***

AWS CLI 命令示例

```
aws sagemaker-mlflow create-presigned-mlflow-app-url \
    --arn <app-arn> \
    --region <region-name> \
    --output text
```

示例输出

```
https://app-LGZEOZ2UY4NZ.mlflow.sagemaker.us-east-1.app.aws/auth?authToken=eyJhbGciOiJIUzI1NiJ9.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.HNvZOfqft4m7pUS52MlDwoi1BA8Vsj3cOfa_CvlT4uw
```

***打开预签名 URL 查看应用程序***

单击 

```
https://app-LGZEOZ2UY4NZ.mlflow.sagemaker.us-east-1.app.aws/auth?authToken=eyJhbGciOiJIUzI1NiJ9.eyJhdXRoVG9rZW5JZCI6IkxETVBPUyIsImZhc0NyZWRlbnRpYWxzIjoiQWdWNGhDM1VvZ0VYSUVsT2lZOVlLNmxjRHVxWm1BMnNhZ3JDWEd3aFpOSmdXbzBBWHdBQkFCVmhkM010WTNKNWNIUnZMWEIxWW14cFl5MXJaWGtBUkVFd09IQmtVbU5IUzJJMU1VTnVaVEl3UVhkUE5uVm9Ra2xHTkZsNVRqTTNXRVJuTTNsalowNHhRVFZvZERneVdrMWlkRlZXVWpGTWMyWlRUV1JQWmpSS2R6MDlBQUVBQjJGM2N5MXJiWE1BUzJGeWJqcGhkM002YTIxek9uVnpMV1ZoYzNRdE1Ub3pNVFF4TkRZek1EWTBPREk2YTJWNUx6Y3dOMkpoTmpjeExUUXpZamd0TkRFeU5DMWhaVFUzTFRrMFlqTXdZbUptT1RJNU13QzRBUUlCQUhnQjRVMDBTK3ErVE51d1gydlFlaGtxQnVneWQ3YnNrb0pWdWQ2NmZjVENVd0ZzRTV4VHRGVllHUXdxUWZoeXE2RkJBQUFBZmpCOEJna3Foa2lHOXcwQkJ3YWdiekJ0QWdFQU1HZ0dDU3FHU0liM0RRRUhBVEFlQmdsZ2hrZ0JaUU1FQVM0d0VRUU1yOEh4MXhwczFBbmEzL1JKQWdFUWdEdTI0K1M5c2VOUUNFV0hJRXJwdmYxa25MZTJteitlT29pTEZYNTJaeHZsY3AyZHFQL09tY3RJajFqTWFuRjMxZkJyY004MmpTWFVmUHRhTWdJQUFCQUE3L1pGT05DRi8rWnVPOVlCVnhoaVppSEFSLy8zR1I0TmR3QWVxcDdneHNkd2lwTDJsVWdhU3ZGNVRCbW9uMUJnLy8vLy93QUFBQUVBQUFBQUFBQUFBQUFBQUFFQUFBUTdBMHN6dUhGbEs1NHdZbmZmWEFlYkhlNmN5OWpYOGV3T2x1NWhzUWhGWFllRXNVaENaQlBXdlQrVWp5WFY0ZHZRNE8xVDJmNGdTRUFOMmtGSUx0YitQa0tmM0ZUQkJxUFNUQWZ3S1oyeHN6a1lDZXdwRlNpalFVTGtxemhXbXBVcmVDakJCOHNGT3hQL2hjK0JQalY3bUhOL29qcnVOejFhUHhjNSt6bHFuak9CMHljYy8zL2JuSHA3NVFjRE8xd2NMbFJBdU5KZ2RMNUJMOWw1YVVPM0FFMlhBYVF3YWY1bkpwTmZidHowWUtGaWZHMm94SDJSNUxWSjNkbG40aGVRbVk4OTZhdXdsellQV253N2lTTDkvTWNidDAzdVZGN0JpUnRwYmZMN09JQm8wZlpYSS9wK1pUNWVUS2wzM2tQajBIU3F6NisvamliY0FXMWV4VTE4N1QwNHpicTNRcFhYMkhqcDEvQnFnMVdabkZoaEwrekZIaUV0Qjd4U1RaZkZsS2xRUUhNK0ZkTDNkOHIyRWhCMjFya2FBUElIQVBFUk5Pd1lnNmFzM2pVaFRwZWtuZVhxSDl3QzAyWU15R0djaTVzUEx6ejh3ZTExZVduanVTai9DZVJpZFQ1akNRcjdGMUdKWjBVREZFbnpNakFuL3Y3ajA5c2FMczZnemlCc2FLQXZZOWpib0JEYkdKdGZ0N2JjVjl4eUp4amptaW56TGtoVG5pV2dxV3g5MFZPUHlWNWpGZVk1QTFrMmw3bDArUjZRTFNleHg4d1FrK0FqVGJuLzFsczNHUTBndUtESmZKTWVGUVczVEVrdkp5VlpjOC9xUlpIODhybEpKOW1FSVdOd1BMU21yY1l6TmZwVTlVOGdoUDBPUWZvQ3FvcW1WaUhEYldaT294bGpmb295cS8yTDFKNGM3NTJUaVpFd1hnaG9haFBYdGFjRnA2NTVUYjY5eGxTN25FaXZjTTlzUjdTT3REMEMrVHIyd0cxNEJ3Zm9NZTdKOFhQeVRtcmQ0QmNKOEdOYnVZTHNRNU9DcFlsV3pVNCtEcStEWUI4WHk1UWFzaDF0dzJ6dGVjVVQyc0hsZmwzUVlrQ0d3Z1hWam5Ia2hKVitFRDIrR3Fpc3BkYjRSTC83RytCRzRHTWNaUE02Q3VtTFJkMnZLbnozN3dUWkxwNzdZNTdMQlJySm9Tak9idWdNUWdhOElLNnpWL2VtcFlSbXJsVjZ5VjZ6S1h5aXFKWFk3TTBXd3dSRzd5Q0xYUFRtTGt3WGE5cXF4NkcvZDY1RS83V3RWMVUrNFIxMlZIUmVUMVJmeWw2SnBmL2FXWFVCbFQ2ampUR0M5TU1uTk5OVTQwZHRCUTArZ001S1d2WGhvMmdmbnhVcU1OdnFHblRFTWdZMG5ZL1FaM0RWNFozWUNqdkFOVWVsS1NCdkxFbnY4SEx0WU9uajIrTkRValZOV1h5T1c4WFowMFFWeXU0ZU5LaUpLQ1hJbnI1N3RrWHE3WXl3b0lZV0hKeHQwWis2MFNQMjBZZktYYlhHK1luZ3F6NjFqMkhIM1RQUmt6dW5rMkxLbzFnK1ZDZnhVWFByeFFmNUVyTm9aT2RFUHhjaklKZ1FxRzJ2eWJjbFRNZ0M5ZXc1QURVcE9KL1RrNCt2dkhJMDNjM1g0UXcrT3lmZHFUUzJWb3N4Y0hJdG5iSkZmdXliZi9lRlZWRlM2L3lURkRRckhtQ1RZYlB3VXlRNWZpR20zWkRhNDBQUTY1RGJSKzZSbzl0S3c0eWFlaXdDVzYwZzFiNkNjNUhnQm5GclMyYytFbkNEUFcrVXRXTEF1azlISXZ6QnR3MytuMjdRb1cvSWZmamJucjVCSXk3MDZRTVR4SzhuMHQ3WUZuMTBGTjVEWHZiZzBvTnZuUFFVYld1TjhFbE11NUdpenZxamJmeVZRWXdBSERCcDkzTENsUUJuTUdVQ01GWkNHUGRPazJ2ZzJoUmtxcWQ3SmtDaEpiTmszSVlyanBPL0h2Z2NZQ2RjK2daM3lGRjMyTllBMVRYN1FXUkJYZ0l4QU5xU21ZTHMyeU9uekRFenBtMUtnL0tvYmNqRTJvSDJkZHcxNnFqT0hRSkhkVWRhVzlZL0NQYTRTbWxpN2pPbGdRPT0iLCJjaXBoZXJUZXh0IjoiQVFJQkFIZ0I0VTAwUytxK1ROdXdYMnZRZWhrcUJ1Z3lkN2Jza29KVnVkNjZmY1RDVXdHeDExRlBFUG5xU1ZFbE5YVUNrQnRBQUFBQW9qQ0Jud1lKS29aSWh2Y05BUWNHb0lHUk1JR09BZ0VBTUlHSUJna3Foa2lHOXcwQkJ3RXdIZ1lKWUlaSUFXVURCQUV1TUJFRURHemdQNnJFSWNEb2dWSTl1d0lCRUlCYitXekkvbVpuZkdkTnNYV0VCM3Y4NDF1SVJUNjBLcmt2OTY2Q1JCYmdsdXo1N1lMTnZUTkk4MEdkVXdpYVA5NlZwK0VhL3R6aGgxbTl5dzhjcWdCYU1pOVQrTVQxdzdmZW5xaXFpUnRRMmhvN0tlS2NkMmNmK3YvOHVnPT0iLCJzdWIiOiJhcm46YXdzOnNhZ2VtYWtlcjp1cy1lYXN0LTE6MDYwNzk1OTE1MzUzOm1sZmxvdy1hcHAvYXBwLUxHWkVPWjJVWTROWiIsImlhdCI6MTc2NDM2NDYxNSwiZXhwIjoxNzY0MzY0OTE1fQ.HNvZOfqft4m7pUS52MlDwoi1BA8Vsj3cOfa_CvlT4uw
```

视图 

![\[Amazon Nova 图像示例。\]](http://docs.aws.amazon.com/zh_cn/nova/latest/nova2-userguide/images/screenshot-nova-model-1.png)


***在 SageMaker HyperPod 配方的 run 代码块中进行配置***

指南

```
run
    mlflow_tracking_uri: arn:aws:sagemaker:us-east-1:111122223333:mlflow-app/app-LGZEOZ2UY4NZ
```

视图

![\[Amazon Nova 图像示例。\]](http://docs.aws.amazon.com/zh_cn/nova/latest/nova2-userguide/images/screenshot-nova-model-2.png)