

# Amazon Nova 모델을 사용한 강화 미세 조정(RFT)
<a name="nova-reinforcement-fine-tuning"></a>

## 개요
<a name="nova-rft-overview"></a>

**RCF란 무엇인가요?**

강화 미세 조정(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을 사용하는 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`를 32,768로 설정해야 합니다.

**각 모드를 사용해야 하는 경우**

다음과 같은 경우 높은 수준의 추론을 사용합니다.
+ 복잡한 분석 태스크
+ 수학적 문제 해결
+ 여러 단계의 논리적 연역
+ 단계별 사고가 가치를 더하는 태스크

다음과 같은 경우에 none(reasoning\_effort) 또는 낮은 수준의 추론을 사용합니다.
+ 단순한 사실적 쿼리
+ 직접 분류
+ 속도 및 비용 최적화
+ 간단한 질문과 답변

**비용 및 성능의 장단점**

추론 모드의 노력이 높아질수록 다음이 증가합니다.
+ 훈련 시간 및 비용
+ 추론 지연 시간 및 비용
+ 복잡한 추론 태스크에 대한 모델 기능

### LLM 판단 검증
<a name="nova-rft-validating-judge"></a>

프로덕션 환경에서 평가형 LLM을 배포하기 전에 평가 모델의 평가가 사람의 평가와 일치하는지 확인합니다. 여기에는 다음이 포함됩니다.
+ 태스크의 대표 샘플에서 LLM 평가와 인적 평가자 간 합의 비율 측정
+ 사람과 LLM의 합의가 사람 간 합의 비율을 충족하거나 초과하도록 보장
+ 평가 모델의 잠재적 편향 식별
+ 보상 신호가 모델을 의도한 방향으로 안내한다는 확신 구축

이 검증 단계는 자동화된 평가 프로세스가 프로덕션 품질 기준을 충족하는 모델을 생성하는 데 도움이 됩니다.

### LLM 평가에 대한 Lambda 구성
<a name="nova-rft-lambda-config"></a>

평가형 LLM 사용은 검증 가능한 보상을 통한 강화 학습(RLVR)에 Lambda 함수를 사용하는 확장입니다. Lambda 함수 내에서 Amazon Bedrock에 호스팅되는 모델 중 하나를 직접 호출합니다.

**중요한 구성 요구 사항:**


| 구성 | 요구 사항 | 세부 정보 | 
| --- | --- | --- | 
| Amazon Bedrock 처리량 | 충분한 할당량 | 사용된 Amazon Bedrock 모델의 처리량 할당량이 훈련 워크로드에 충분하도록 보장 | 
| Lambda 제한 시간 | 연장된 제한 시간 | 최대 15분으로 Lambda 함수 제한 시간을 구성합니다. 기본 설정은 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 위치에서 `manifest.json` 파일(노트북의 `output_s3_uri`에 의해 정의)

## 제한 사항 및 모범 사례
<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. **예측** - 모델은 퓨삿 예측 형식을 사용하여 각 후보 프롬프트의 통과율(또는 보상 분산)을 예측합니다. 이전 훈련 단계의 예제 3개(쉬움 1개, 중간 1개, 어려움 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.
```

다음 표에서는 각 적응형 커리큘럼 파라미터를 설명합니다.


| 파라미터 | 유형 | 기본값 | 설명 | 
| --- | --- | --- | --- | 
| 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²)) 프롬프트가 약 8,000개의 토큰을 초과하는 데이터세트에서 선별로 단계 시간 대부분이 소요될 수 있습니다.

**참고**  
적응형 커리큘럼은 토큰이 최대 32,768개(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\_lookahead\_steps: 1와 함께 selection\_pool\_multiplier: 4을 사용합니다. 예측기가 최소 크기의 풀에서 훈련 단계당 한 번 실행됩니다. 이 설정은 지원되는 설정 중 가장 적극적이며, 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분을 초과하는 보상 함수
+ 추가 알고리즘 및 조정 옵션
+ 사용자 지정 훈련 레시피 수정
+ 첨단 AI 기술

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)를 참조하세요.