# 使用 Amazon Nova 模型进行强化微调（RFT）
<a name="nova-reinforcement-fine-tuning"></a>

## 概述
<a name="nova-rft-overview"></a>

**什么是 RFT？**

强化微调（RFT）通过基于反馈信号（即指示模型表现优劣的可衡量分数或奖励）的训练来提升模型性能，而不是基于精确的正确答案。与从输入-输出对中学习的监督式微调（SFT）不同，RFT 使用奖励函数来评测模型响应，并迭代优化模型以获得最高奖励。这种方法适用于难以定义精确输出但能可靠衡量响应质量的任务。

**何时使用 RFT**

当您能够定义清晰、可衡量的成功标准，但难以精确提供正确的输出用于训练时，可使用 RFT。RFT 非常适合下列使用案例：
+ 质量具有主观性或多维度的任务，如创意写作、代码优化或复杂推理
+ 存在多种可行方案，但部分方案明显更优的场景
+ 需要迭代改进、个性化或遵循复杂业务规则的应用
+ 收集高质量标注样本成本过高或不切实际的情况

**最佳使用案例**

在输出质量可客观衡量、但最优应答难以预先定义的领域，RFT 表现优异：
+ 数学问题求解和代码生成
+ 科学推理与结构化数据分析
+ 需要逐步推理或多轮问题求解的任务
+ 兼顾多个目标（准确率、效率、风格）的应用
+ 可通过执行结果或性能指标以编程方式验证成功与否的场景

**支持的模型**

Nova Lite 2.0

## 数据格式概述
<a name="nova-rft-data-format"></a>

RFT 训练数据必须遵循 OpenAI 强化微调[格式](https://platform.openai.com/docs/api-reference/fine-tuning/reinforcement-input)。每个训练样本都是一个 JSON 对象，其中包含：
+ 包含 `system` 和 `user` 角色对话轮次的 `messages` 数组
+ 包含用于奖励计算的期望输出或评测标准的 `reference_answer` 字段

**目前的局限性**
+ 仅文本

### 数据格式示例
<a name="nova-rft-data-examples"></a>

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

------
#### [ Chemistry problem ]

```
{
  "id": "chem-01",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful chemistry assistant"
    },
    {
      "role": "user",
      "content": "Calculate the molecular weight of caffeine (C8H10N4O2)"
    }
  ],
  "reference_answer": {
    "molecular_weight": 194.19,
    "unit": "g/mol",
    "calculation": "8(12.01) + 10(1.008) + 4(14.01) + 2(16.00) = 194.19"
  }
}
```

------
#### [ Math problem ]

```
{
  "id": "sample-001",  // Optional
  "messages": [
    {
      "role": "system",
      "content": "You are a math tutor"
    },
    {
      "role": "user",
      "content": "Solve: 2x + 5 = 13"
    }
  ],
  "reference_answer": {
    "solution": "x = 4",
    "steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
  }
}
```

------
#### [ Code problem ]

```
{
  "id": "code-002",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful programming assistant"
    },
    {
      "role": "user",
      "content": "Write a Python function that reverses a string without using built-in reverse methods"
    }
  ],
  "reference_answer": {
    "code": "def reverse_string(s):  \n    result = ''  \n    for i in range(len(s) - 1, -1, -1):  \n        result += s[i]  \n    return result",
    "test_cases": [
      {
        "input": "hello",
        "expected_output": "olleh"
      },
      {
        "input": "",
        "expected_output": ""
      },
      {
        "input": "a",
        "expected_output": "a"
      },
      {
        "input": "Python123",
        "expected_output": "321nohtyP"
      }
    ],
    "all_tests_pass": true
  }
}
```

------

`reference_answer` 字段包含期望输出或评测标准，供奖励函数对模型响应进行评分。其不限于结构化输出，可采用任何有助于奖励函数评测质量的格式。

## 数据集规模建议
<a name="nova-rft-dataset-size"></a>

**起步要求**
+ 至少 100 个训练样本
+ 至少 100 个评测样本

**评测优先的方法**

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

从小规模数据集开始，可实现以下效果：
+ 验证奖励函数无错误
+ 确认 RFT 适合于使用案例
+ 尽早发现并修复问题
+ 在扩展规模前测试工作流

验证通过后，即可扩展到更大规模的数据集，进一步提升模型性能。

## 有效训练数据的特征
<a name="nova-rft-effective-data"></a>

**清晰性与一致性**

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

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

**多样性**

数据集应覆盖生产环境中的各类使用案例，确保模型在真实环境中表现稳健。包含：
+ 不同的输入格式和边界情况
+ 从日志和用户分析中映射实际的生产使用模式
+ 跨用户类型、地理区域和季节性变化的采样
+ 包含从简单到复杂的问题难度级别

**奖励函数注意事项**

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

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

## 其它属性
<a name="nova-rft-additional-properties"></a>

RFT 数据格式支持核心架构要求（`messages` 和 `reference_answer`）之外的自定义字段。这种灵活性支持您添加奖励函数完成有效评测所需的任意附加数据。

**注意**  
无需在配方中进行配置，该数据格式原生支持附加字段。只需将其包含在训练数据的 JSON 中，即可通过 `metadata` 字段传递给奖励函数。

**常见附加属性**

元数据字段示例：
+ `task_id`：用于跟踪的唯一标识符
+ `difficulty_level`：问题复杂度指示符
+ `domain`：主题领域或类别
+ `expected_reasoning_steps`：解题过程中的步骤数

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

```
{
  "messages": [
    {
      "role": "system",
      "content": "You are a math tutor"
    },
    {
      "role": "user",
      "content": "Solve: 2x + 5 = 13"
    }
  ],
  "reference_answer": {
    "solution": "x = 4",
    "steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
  },
  "task_id": "algebra_001",
  "difficulty_level": "easy",
  "domain": "algebra",
  "expected_reasoning_steps": 3
}
```

这些附加字段将在评测期间传递给奖励函数，从而实现针对特定使用案例量身定制的复杂评分逻辑。

## 训练配置
<a name="nova-rft-training-config"></a>

**配方示例**

```
# Note:
# This recipe can run on p5.48xlarge, p5e.48xlarge, and p5en.48xlarge instance types.
run:
  name: "my-rft-run"                           # Unique run name (appears in logs and artifacts).
  model_type: amazon.nova-2-lite-v1:0:256k
  model_name_or_path: nova-lite-2/prod
  data_s3_path: s3://<bucket>/<data-file>      # Training dataset in JSONL format.
  replicas: 4                                   # Number of total training instances.
  generation_replicas: 2                        # Number of total instances dedicated to response generation.
  reward_lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>

  ## MLFlow configs
  mlflow_tracking_uri: "" # Required for MLFlow
  mlflow_experiment_name: "my-rft-experiment" # Optional for MLFlow. Note: leave this field non-empty
  mlflow_run_name: "my-rft-run" # Optional for MLFlow. Note: leave this field non-empty

## SMTJ RFT training configs
training_config:
  max_length: 8192                              # Context window (tokens) for inputs and prompt.
  global_batch_size: 32                         # Total samples per optimizer step across all replicas (16/32/64/128/256).
  reasoning_effort: high                        # Reasoning mode: high, low, or null for non-reasoning.

  data:
    shuffle: true                               # Shuffle training data each epoch.

  rollout:                                      # Controls how responses are generated for advantage calculation.
    rollout_strategy:
      type: off_policy_async                    # Asynchronous rollout for higher throughput.
      age_tolerance: 2                          # Maximum policy age before regeneration.
    advantage_strategy:
      number_generation: 4                      # Samples per prompt to estimate advantages (higher = lower variance but higher cost).
    generator:
      max_new_tokens: 6000                      # Cap on tokens generated per sample.
      set_random_seed: true                     # Seed generation for reproducibility across runs.
      temperature: 1                            # Softmax temperature for sampling.
    rewards:
      preset_reward_function: null              # Preset reward functions: exact_match or null for custom.
      api_endpoint:
        lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>
        lambda_concurrency_limit: 12             # Max concurrent Lambda invocations (throughput vs. throttling).
        lambda_batch_size: 128                  # Number of samples per Lambda invocation.

  trainer:
    max_steps: 2                                # Steps to train for. One step = global_batch_size samples.
    save_steps: 5                               # Save a checkpoint every N steps.
    test_steps: 1                               # Run validation every N reference model updates.
    refit_freq: 4                               # Frequency of reference model updates.
    clip_ratio_high: 0.2                        # PPO clip ratio for policy updates.
    loss_scale: 1.0                             # Scaling factor for the policy loss.

    # RL parameters
    ent_coeff: 0.0                              # Entropy bonus added to the policy loss (higher = more exploration).
    kl_loss_coef: 0.0                           # Weight on the KL penalty between the current and reference policy.

    optim_config:                               # Optimizer settings.
        lr: 1e-6                                # Learning rate.
        weight_decay: 0.0                       # L2 regularization strength (0.0 to 1.0).
        adam_beta1: 0.9
        adam_beta2: 0.95

    peft:                                       # Parameter-efficient fine-tuning (LoRA).
        peft_scheme: "lora"                     # Enable LoRA for PEFT.
        lora_tuning:
            alpha: 64                           # LoRA scaling factor.
            lora_plus_lr_ratio: 64.0            # LoRA+ learning rate scaling factor (0.0 to 100.0).
```

## 使用 LLM-as-a-judge 的 RFT 训练
<a name="nova-rft-llm-judge"></a>

### 概述
<a name="nova-rft-llm-judge-overview"></a>

大语言模型（LLM）越来越多地被用作强化微调（RFT）工作流中的评判工具，提供自动化的奖励信号来指导模型优化。在这种方法中，LLM 会根据指定标准对模型输出进行评测（包括正确性、质量、风格一致性或语义等效性等），并分配用于驱动强化学习过程的奖励值。

对于传统奖励函数难以通过编程定义的任务，该方法尤为实用。例如判断不同表达形式（如“1/3”“0.333”和“三分之一”）是否语义等效，或评测连贯性、相关性等细微特征。通过将基于 LLM 的评判机制作为奖励函数，可将 RFT 扩展到复杂领域，无需大量人工标注，进而在传统对齐问题之外的各类场景中，实现模型的快速迭代与持续优化。

### 推理模式选择
<a name="nova-rft-reasoning-mode"></a>

**可用模式**
+ none：无推理（省略 reasoning\_effort 字段）
+ low：最小推理开销
+ high：最大推理能力（指定了 reasoning\_effort 时，此为默认值）

**注意**  
RFT 无中等选项。如果配置中不含 reasoning\_effort 字段，则禁用推理。启用推理时，建议将 `max_new_tokens` 设置为 32768，以容纳更长的推理输出内容。

**何时使用各个模式**

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

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

**成本与性能权衡**

较高强度推理模式会导致：
+ 训练时间和成本增加
+ 推理延迟和成本增加
+ 模型在复杂推理任务上的能力提升

### 验证 LLM 评判工具
<a name="nova-rft-validating-judge"></a>

在生产中部署 LLM-as-a-judge 之前，请验证评判工具模型的评测是否与人类判断一致。这涉及：
+ 测量 LLM 评判工具与人工评测员在任务代表性样本上的一致率
+ 确保 LLM 与人类评测的一致率达到或超过人类之间的一致率
+ 识别评判工具模型中可能存在的偏差
+ 建立信心，确保奖励信号能按预期方向引导模型

此验证步骤有助于确保自动化评测过程能够产生符合生产质量标准的模型。

### LLM 评判工具的 Lambda 配置
<a name="nova-rft-lambda-config"></a>

采用 LLM-as-a-judge，是对使用 Lambda 函数实现可验证奖励强化学习（RLVR）的扩展。在 Lambda 函数内部，需调用 Amazon Bedrock 中托管的任一模型。

**重要配置要求：**


| 配置 | 要求 | Details | 
| --- | --- | --- | 
| Amazon Bedrock 吞吐量 | 充足的配额 | 确保所使用的 Amazon Bedrock 模型吞吐量配额足以满足训练工作负载 | 
| Lambda 超时 | 延长超时 | 将 Lambda 函数超时配置为最多 15 分钟。默认设置为 3 秒，不足以满足 Amazon Bedrock 模型的响应需求 | 
| Lambda 并发 | 提高并发 | Lambda 在训练期间会被并行调用。提高并发以提供最大程度的可用吞吐量 | 
| 配方配置 | 匹配 Lambda 设置 | 并发限制必须在配方中进行配置 | 

## 创建与运行作业
<a name="nova-rft-creating-jobs"></a>

**启动训练作业**

使用 SageMaker 训练作业笔记本模板：[https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-fine-tuning-training-job.html#nova-model-training-jobs-notebook)

**实例要求**

容器同时支持全秩和 LoRA 训练：
+ **LoRA 训练**：2/4/6/8 个 p5.48xlarge 或 p5en.48xlarge 实例
+ **全秩训练**：2/4/6/8 个 p5.48xlarge 实例（必需）

## 监控训练
<a name="nova-rft-monitoring"></a>

训练日志包含每一步的全面指标。主要指标类别：

**奖励指标**
+ `critic/rewards/mean`、`critic/rewards/max`、`critic/rewards/min`：奖励分布
+ `val-score/rewards/mean@1`：验证奖励

**模型行为**
+ `actor/entropy`：策略多样性（值越高表示探索性越强）

**训练健康度**
+ `actor/pg_loss`：策略梯度损失
+ `actor/pg_clipfrac`：裁剪更新频率
+ `actor/grad_norm`：梯度范数

**响应特征**
+ `prompt_length/mean`、`prompt_length/max`、`prompt_length/min`：输入词元统计
+ `response_length/mean`、`response_length/max`、`response_length/min`：输出词元统计
+ `response/aborted_ratio`：不完整生成率（0 表示全部完成）

**性能**
+ `perf/throughput`：训练吞吐量
+ `perf/time_per_step`：每步训练时间
+ `timing_per_token_ms/*`：每个词元的处理时间

**资源使用**
+ `perf/max_memory_allocated_gb`、`perf/max_memory_reserved_gb`：GPU 内存
+ `perf/cpu_memory_used_gb`：CPU 内存

## 使用经过微调的模型
<a name="nova-rft-using-models"></a>

训练完成后，最终模型检查点将保存到指定的输出位置。检查点路径可在以下位置获取：
+ 训练日志
+ 输出 Amazon S3 位置（由笔记本中的 `output_s3_uri` 定义）中的 `manifest.json` 文件

## 限制与最佳实践
<a name="nova-rft-limitations"></a>

**限制**
+ **Lambda 超时**：奖励函数须在 15 分钟内执行完毕（防止进程失控并控制成本）
+ **仅支持单轮对话**：不支持多轮对话
+ **数据要求**：需具备充足的多样性；在稀疏奖励场景下（正例占比 ＜5%）训练难度较高
+ **计算成本**：比监督式微调更昂贵
+ **无多模态数据**：仅支持文本数据类型

**最佳实践**

**从小规模起步**
+ 从 100 – 200 个样本开始
+ 验证奖励函数正确性
+ 根据结果逐步扩展

**训练前评测**
+ 在 RFT 之前测试基线模型性能
+ 如果奖励始终为 0%，建议先通过 SFT 训练构建基础能力
+ 若奖励占比 ＞95%，则可能无需进行 RFT

**监控训练**
+ 跟踪平均奖励分数和分布
+ 注意过拟合（练奖励上升，而验证奖励下降）
+ 留意异常模式：
  + 奖励在 0.15 以下趋于平稳
  + 奖励方差随时间逐步增大
  + 验证性能下降

**优化奖励函数**
+ 在几秒钟内执行完毕（而非几分钟）
+ 尽量减少外部 API 调用
+ 使用高效算法
+ 实现完善的错误处理机制
+ 充分利用 Lambda 的并行扩展能力

**迭代策略**

如果奖励没有提升：
+ 调整奖励函数设计
+ 提升数据集多样性
+ 添加更多代表性样本
+ 确保奖励信号清晰一致

## 自适应课程学习
<a name="nova-rft-adaptive-curriculum"></a>

自适应课程学习是一项可选功能，会在 RFT 期间动态选择要向模型呈现训练提示。训练者不会对所有提示进行完全一样的训练，而是使用模型本身来预测提示难度，然后在生产率难度范围内选择提示。在这种情况下，模型有时会成功，有时会失败，但可以尽可能提高每个 GRPO 推出组内的结果方差，从而产生更高的优势信号、更快的收敛速度，并通过减少过于简单或太难的提示所产生噪音梯度更新，从而增强 RL 训练的稳定性。

### 自适应课程的工作原理
<a name="nova-rft-adaptive-curriculum-how"></a>

启用自适应课程后，训练循环会在每个推出步骤之前添加一个预测和选择阶段：

1. **预测**：模型使用少样本预测格式来预测每个候选提示的通过率（或奖励点差）。上一训练步骤中的三个范例（一个简单、一个中等、一个困难）提供了校准上下文。

1. **选择**：提示按其预测难度与选择目标的接近程度排名（默认值：50% 通过率）。最佳提示获准推出；其余提示予以丢弃，不会消耗推出计算资源。

1. **训练**：对选定的提示执行标准 GRPO 训练。

1. **反馈**：将推出后的实际通过率与预测进行比较。自动校准选择目标以纠正系统性预测偏向。使用 REINFORCE 梯度来训练预测器，以改进未来的预测。

### 何时使用自适应课程
<a name="nova-rft-adaptive-curriculum-when"></a>

自适应课程对于下列场景最为有效：
+ 您希望通过确保每个训练批次都包含都具有有意义奖励方差的提示，提高 RL 训练的稳定性，从而减少可能破坏学习稳定性的嘈杂梯度更新。
+ 您已确认基本 RFT 能够改善您的目标指标。
+ 您希望通过将训练计算资源重点用于生产率最高的提示来加快收敛速度。
+ 您的数据集非常大（超过 5,000 个提示），并且包含许多超出生产率难度范围，本会浪费计算资源的提示。

### 配置自适应课程
<a name="nova-rft-adaptive-curriculum-config"></a>

在配方的 `trainer` 下添加 `adaptive_curriculum` 数据块，以启用自适应课程学习：

```
training_config:
  trainer:
    adaptive_curriculum:
      enable: true                               # Enable adaptive curriculum prompt selection.
      selection_pool_multiplier: 8               # Score 8 x global_batch_size candidates, keep best global_batch_size.
      prediction_mode: pass_rate                 # "pass_rate" for discrete rewards; "spread" for continuous rewards.
      exemplar_history_steps: 1                  # Previous training steps kept in the rolling exemplar history buffer.
      reinforce_coef: 0.01                       # Scale factor for the REINFORCE loss that trains the predictor (0 disables).
      predictor_prompt_column: predictor_prompt  # Dataset field with clean problem text used by the predictor.
      selection_lookahead_steps: 4               # Future training batches pre-approved per curriculum screening pass.
```

下表介绍了每个自适应课程参数：


| 参数 | Type | 默认值 | 说明 | 
| --- | --- | --- | --- | 
| enable | 布尔值 | false | 是否启用自适应课程提示选择。 | 
| selection\_pool\_multiplier | 整数（1–32） | 8 | 控制相对于训练批次大小，要进行评分的候选提示数量。值为 8 表示要对 8 × 个 global\_batch\_size 提示进行评分，并选择最佳的 global\_batch\_size。该值越高，选择质量越好，但推理计算成本也会越高。 | 
| prediction\_mode | 字符串 | pass\_rate | 用于提示难度估算的预测模式。离散奖励任务（例如正确性检查）应使用 pass\_rate，预测器会估算正确答案的概率。连续奖励任务应使用 spread，预测器会估算不同推出的最大最小奖励点差。 | 
| exemplar\_history\_steps | 整数（≥1） | 1 | 要在滚动历史缓冲区中保留的之前训练步骤数量，以用于范例选择。预测器使用该历史记录中的范例来校准其少样本预测。 | 
| reinforce\_coef | 数值（≥0） | 0.01 | 训练通过率预测器的 REINFORCE 损失比例系数。这样可以实现闭环学习，预测器会在训练过程中不断提高准确性。设置为 0 会禁用预测器训练。 | 
| predictor\_prompt\_column | 字符串 | predictor\_prompt | 数据集中包含用作预测器提示的清洗问题文本的字段名称。这应是问题的简明版本，不含系统提示或格式，从而让预测器可以快速评估难度。 | 
| selection\_lookahead\_steps | 整数（1–16） | 4 | 单次课程筛选通过时需要在每个步骤预批准的未来训练批次数量。每次通过时会在每个步骤对 selection\_pool\_multiplier × global\_batch\_size 个候选提示进行评分；较高的 selection\_lookahead\_steps 值会多次重复该次通过，从而积累已批准提示队列，减少短提示数据集上的每步预测器开销。对于预测器本身就很昂贵的长上下文数据集（参见“推荐”部分），请将其设置为 1，以确保预测器在每个步骤只运行一次。 | 

### 有关长上下文数据集的建议
<a name="nova-rft-adaptive-curriculum-long-context"></a>

自适应课程的原理是对候选提示集运行一个轻量级通过率预测器，然后选择生产率最高的批次进行推出。当 `max_prompt_length` 很短（只有几千个或以下的词元）时，每次筛选通过时预测器在几秒钟内即可完成运行，课程开销可以忽略不计。随着提示长度增加，预测器的推理时间会大致呈二次方倍增长（按照序列长度，注意力为 O(n²)），因此如果数据集的提示超过大约 8000 个词元时，筛选可能会占据步骤的大部分时间。

**注意**  
自适应课程支持不超过 32768 个词元（32K）的 `max_prompt_length`。不支持为超过此长度的数据集启用自适应课程；请禁用自适应课程或缩短提示，然后再开始训练。

以下设置有助提高自适应课程对长上下文数据集的实用性和成本效益。这些设置分别针对筛选成本的不同组成部分，因此应将其组合使用。


| 典型 `max_prompt_length` | 推荐的自适应课程设置 | 
| --- | --- | 
| 最多 8K 个词元 | 使用默认值：selection\_pool\_multiplier: 8、selection\_lookahead\_steps: 4。筛选开销很小，不需要调整。 | 
| 词元数量超过 8K 个，但不超过 16K 个 | 设置 selection\_lookahead\_steps: 2。这样可以将每个步骤的预测器通过次数减半，同时在队列中保留足够经预批准的提示，以避免推出时提示不足。 | 
| 词元数量超过 16K 个，但不超过 24K 个 | 保留 selection\_lookahead\_steps: 2 并将 selection\_pool\_multiplier 降低至 4。较小的提示集可将预测器批次大小减半，对选择质量有一定影响；但将这些设置结合可限制每步筛选时间。 | 
| 词元数量超过 24K 个，但不超过 32K 个 | 将 selection\_pool\_multiplier: 4 与 selection\_lookahead\_steps: 1 结合使用。预测器在每个训练步骤使用最小的提示集运行一次。这是支持的最激进设置；不支持超过 32K 个词元的提示集。 | 

针对长上下文数据集调整配置的示例（大约 24K–32K 个词元提示）：

```
training_config:
  max_length: 32768
  global_batch_size: 32

  trainer:
    adaptive_curriculum:
      enable: true
      selection_pool_multiplier: 4        # Smaller pool keeps predictor prefill bounded.
      selection_lookahead_steps: 1        # Predictor runs once per training step.
      prediction_mode: pass_rate
      exemplar_history_steps: 1
      reinforce_coef: 0.01
      predictor_prompt_column: predictor_prompt
```

### 自适应课程的数据准备
<a name="nova-rft-adaptive-curriculum-data"></a>

使用自适应课程时，训练数据应包含一个 `predictor_prompt` 字段（或具有 `predictor_prompt_column` 中指定字段名称的字段），其中包含问题文本的简明版本。通过率预测器使用该字段来快速评估提示难度，而无需处理完整的对话上下文。

使用预测器提示的 JSONL 输入示例：

```
{
  "messages": [
    {
      "role": "system",
      "content": "You are a math tutor. Show your work step by step."
    },
    {
      "role": "user",
      "content": "A train travels 120 miles in 2 hours. If it then increases speed by 50%, how far will it travel in the next 3 hours?"
    }
  ],
  "reference_answer": "270 miles",
  "predictor_prompt": "A train travels 120 miles in 2 hours. Speed increases 50%. Distance in next 3 hours?"
}
```

如果 `predictor_prompt` 字段不存在，则系统会回退为使用来自 `messages` 字段的完整提示。

### 使用自适应课程的完整配方示例
<a name="nova-rft-adaptive-curriculum-example"></a>

以下示例演示了一个启用了自适应课程设置的完整 LoRA RFT 配方：

```
run:
  name: "my-rft-adaptive-curriculum"
  model_type: amazon.nova-2-lite-v1:0:256k
  model_name_or_path: nova-lite-2/prod
  data_s3_path: s3://<bucket>/<data-file>
  replicas: 4
  generation_replicas: 2
  reward_lambda_arn: arn:aws:lambda:<region>:<account-id>:function:<function-name>

training_config:
  max_length: 8192
  global_batch_size: 32
  reasoning_effort: null                        # Non-reasoning mode.

  data:
    shuffle: true

  rollout:
    rollout_strategy:
      type: off_policy_async
      age_tolerance: 2
    advantage_strategy:
      number_generation: 16                     # Higher n for better advantage estimates.
    generator:
      max_new_tokens: 6000
      temperature: 1.0
    rewards:
      preset_reward_function: exact_match       # Or null for custom Lambda reward.
      api_endpoint:
        lambda_arn: ${oc.select:run.reward_lambda_arn}   # Reuse the top-level run.reward_lambda_arn so the two stay in sync.
        lambda_concurrency_limit: 12
        lambda_batch_size: 128

  trainer:
    max_steps: 500
    save_steps: 50
    test_steps: 25
    refit_freq: 4
    clip_ratio_high: 0.2
    ent_coeff: 0.0
    kl_loss_coef: 0.0

    optim_config:
      lr: 1e-6
      weight_decay: 0.0

    peft:
      peft_scheme: "lora"
      lora_tuning:
        alpha: 64
        lora_plus_lr_ratio: 64.0

    adaptive_curriculum:
      enable: true
      selection_pool_multiplier: 8
      prediction_mode: pass_rate
      exemplar_history_steps: 1
      reinforce_coef: 0.01
      predictor_prompt_column: predictor_prompt
```

### 监控自适应课程
<a name="nova-rft-adaptive-curriculum-monitoring"></a>

启用自适应课程后，将在每个训练步骤中记录额外的指标：
+ **预测通过率与实际通过率**：所选提示的平均预测通过率与推出后实际观察到的通过率比较。如果差距较大，则表示预测器需要更多的校准时间。
+ **选择目标**：当前自动校准后的选择目标。该值从 0.5 开始，并根据预测准确度进行调整。
+ **已掌握筛选条件数**：由于模型已经稳定掌握，而予以排除的提示数量。

**注意**  
最初 1-2 个训练步骤会不进行自适应选择的情况下运行（预测器需要至少有一个历史步骤才能构建范例）。完全自适应选择将从第 3 步开始。

## 高级能力：Nova Forge
<a name="nova-rft-advanced"></a>

对于需要突破标准 RFT 限制的高级能力的用户，Nova Forge 作为付费订阅服务提供，包括：
+ 多轮对话支持
+ 执行时间超过 15 分钟的奖励函数
+ 额外的算法和调优选项
+ 自定义训练配方修改
+ 最先进的人工智能技术

Nova Forge 在 SageMaker HyperPod 上运行，旨在支持企业客户构建自己的前沿模型。

## 实用命令与技巧
<a name="nova-rft-useful-commands"></a>

您可使用一系列[可观测性脚本](https://github.com/aws-samples/amazon-nova-samples/tree/main/customization/SageMakerUilts/SageMakerJobsMonitoring)，帮助监控训练作业的状态和进度。

可用脚本包括：
+ 为训练作业状态更新启用电子邮件通知
+ 根据作业配置获取训练时间估算
+ 获取进行中作业的预期训练时间近似值

**安装**

**注意**  
在使用以下任何脚本之前，请务必刷新 AWS 凭证。

```
pip install boto3
git clone https://github.com/aws-samples/amazon-nova-samples.git
cd amazon-nova-samples/customization/SageMakerUilts/SageMakerJobsMonitoring/
```

**基本用法**

```
# Enabling email notifications for training job status updates
python enable_sagemaker_job_notifs.py --email test@amazon.com test2@gmail.com --region us-east-1 --platform SMTJ

Creating resources........
Please check your email for a subscription confirmation email, and click 'Confirm subscription' to start receiving job status email notifications!
You'll receive the confirmation email within a few minutes.
```

```
# Obtaining training time estimates based on job configurations
python get_training_time_estimate.py
```

```
# Obtaining approximations for how long training is expected to take for in-progress jobs
python get-training-job-progress.py --region us-east-1 --job-name my-training-job --num-dataset-samples 1000
```

有关更多详细信息和示例，请参阅[此处](https://github.com/aws-samples/amazon-nova-samples/blob/main/customization/SageMakerUilts/SageMakerJobsMonitoring/README.md)。