

# 훈련된 모델 평가
<a name="nova-hp-evaluate"></a>

평가 레시피는 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)

# 사용 가능한 벤치마크 태스크
<a name="customize-fine-tune-evaluate-available-tasks"></a>

Amazon Nova에 대한 SageMaker AI 모델 평가 기능을 사용하여 벤치마크 지표를 계산하는 방법을 보여주는 샘플 코드 패키지를 사용할 수 있습니다. 코드 패키지에 액세스하려면 [sample-Nova-lighteval-custom-task](https://github.com/aws-samples/sample-Nova-lighteval-custom-task/)를 참조하세요.

다음은 지원되는 업계 표준 벤치마크 목록입니다. `eval_task` 파라미터에 다음 벤치마크를 지정할 수 있습니다.


| 벤치마크 | 양식 | 설명 | Metrics | 전략 | 하위 태스크 사용 가능 | 
| --- |--- |--- |--- |--- |--- |
| 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 선호도 비교 - Amazon Nova Judge 모델을 사용하여 프롬프트에 대한 응답 페어 사이에서 선호도를 판별하여(A를 기준으로 B 비교) 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 평가 모델입니다. 기본 설정 결정만 제공하는 [원래 평가 모델](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 - 고급 수학 추론 및 문제 해결을 테스트하는 미국 초대 수학 검사 문제  |  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",
]
```

# 레시피 파라미터 이해
<a name="customize-fine-tune-evaluate-understand-modify"></a>

**실행 구성**  
다음은 일반적인 실행 구성과 관련 파라미터에 대한 설명입니다.

```
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* 레시피를 사용하는 경우가 아니면 이 파라미터를 비워 둡니다.
+ `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 및 mm\$1llm\$1judge에 특정한 전략.
+ `subtask`: (선택 사항, 제거 가능) 특정 평가 태스크에 대한 특정 하위 태스크를 지정합니다. 태스크에 하위 태스크가 없는 경우 레시피에서 이를 제거합니다.
+ `metric`: (필수) 사용할 평가 지표입니다.
  + accuracy: 정답 비율입니다.
  + exact\$1match: (`math` 벤치마크의 경우) 입력 예측 문자열이 참조와 정확히 일치하는 비율을 반환합니다.
  + deflection: (`strong reject` 벤치마크의 경우) 기본 모델에 대한 상대 편향과 중요도 지표의 차이를 반환합니다.
  + pass@1: (`humaneval` 벤치마크의 경우) 모델의 최고 신뢰도 예측이 정답과 일치하는 사례의 비율을 측정하는 데 사용되는 지표입니다.
  + `all`: 다음 지표를 반환합니다.
    + `gen_qa` 및 사용자 제공 데이터세트 벤치마크의 경우 다음 지표를 반환합니다.
      + `rouge1`: 생성된 텍스트와 참조 텍스트 간의 유니그램(단일 단어) 중복을 측정합니다.
      + `rouge2`: 생성된 텍스트와 참조 텍스트 간의 바이그램(2개 연속 단어) 중복을 측정합니다.
      + `rougeL`: 텍스트 간에 가장 긴 공통 부분 수열을 측정하며, 일치 항목 간의 간격을 허용합니다.
      + `exact_match`: 생성된 텍스트가 문자별로 참조 텍스트와 정확히 일치하는지 여부를 나타내는 이진 점수(0 또는 1)입니다.
      + `quasi_exact_match`: exact\$1match와 유사하지만 일반적으로 대소문자, 구두점 및 공백 차이를 무시하는 더 관대한 일치 방식입니다.
      + `f1_score`: 정밀도와 재현율의 조화 평균으로, 예측된 답변과 참조 답변 간의 단어 중복을 측정합니다.
      + `f1_score_quasi`: f1\$1score와 유사하지만 사소한 차이를 무시하는 정규화된 텍스트 비교를 사용하는 더 관대한 일치 방식입니다.
      + `bleu`: 생성된 텍스트와 참조 텍스트 간의 n그램 일치 정밀도를 측정하며, 일반적으로 번역 평가에 사용됩니다.
    + `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`: 쌍별 판단에서 ties의 표준 오차입니다.
      + `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\$11.0 범위의 부동 소수점 수여야 합니다.
+ `temperature`: 토큰 선택의 무작위성입니다. 값이 클수록 무작위성이 커집니다. 결과를 결정론적으로 만들려면 0을 사용합니다. 이 값은 최소값이 0인 부동 소수점 수여야 합니다.
+ `top_logprobs`: 추론 응답에서 반환할 상위 logprobs 수. 이 값은 0\$120의 정수여야 합니다. Logprobs에는 메시지 콘텐츠에서 반환된 각 출력 토큰의 고려된 출력 토큰 수와 로그 확률이 포함됩니다.
+ `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`: (선택 사항) 관련 ML 실행을 그룹화하는 실험의 이름
+ `mlflow_run_name`: (선택 사항) 실험 내 특정 훈련 실행의 사용자 지정 이름

# 평가 레시피 예시
<a name="customize-fine-tune-evaluate-recipe-examples"></a>

Amazon Nova는 SageMaker HyperPod 레시피 GitHub 리포지토리에서 사용할 수 있는 네 가지 유형의 평가 레시피를 제공합니다.

## 일반 텍스트 벤치마크 레시피
<a name="nova-model-hp-evaluation-config-example-text"></a>

이러한 레시피를 사용하면 광범위한 텍스트 전용 벤치마크 모음 전반에서 Amazon Nova 모델의 기본 기능을 평가할 수 있습니다. 이는 `xxx_general_text_benchmark_eval.yaml` 형식으로 제공됩니다.

## 사용자 제공 데이터세트 벤치마크 레시피
<a name="nova-model-hp-evaluation-config-byo"></a>

이러한 레시피를 사용하면 벤치마킹을 위한 자체 데이터세트를 가져와서 다양한 유형의 지표를 사용하여 모델 출력을 참조 답변과 비교할 수 있습니다. 이는 `xxx_bring_your_own_dataset_eval.yaml` 형식으로 제공됩니다.

다음은 사용자 제공 데이터세트 요구 사항입니다.
+ 파일 형식 요구 사항
  + 평가 예시가 포함된 단일 `gen_qa.jsonl` 파일을 포함해야 합니다.
  + SageMaker 훈련 작업이 액세스할 수 있는 S3 위치에 데이터세트를 업로드해야 합니다.
  + 파일은 일반 Q&A 데이터세트에 필요한 스키마 형식을 따라야 합니다.
+ 스키마 형식 요구 사항 - 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 벤치마크 레시피
<a name="nova-model-evaluation-config-llm-judge"></a>

평가형 Amazon Nova LLM은 고객이 사용자 지정 데이터세트에서 한 모델의 응답 품질을 기준 모델 응답과 비교하는 모델 평가 기능입니다. 프롬프트, 기준 응답 및 도전자 응답이 있는 데이터세트를 가져오고 Amazon Nova Judge 모델을 사용하여 페어별 비교를 통해 [Bradley-Terry 확률](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model)로 승률 지표를 제공합니다.

이 레시피는 `xxx_llm_judge_eval.yaml` 형식으로 제공됩니다.

다음은 평가형 LLM 요구 사항입니다.
+ 파일 형식 요구 사항
  + 평가 예시가 포함된 단일 `llm_judge.jsonl` 파일을 포함합니다. 파일 이름은 `llm_judge.jsonl`이어야 합니다.
  + [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 예시 항목입니다.

```
{
"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
<a name="nova-model-hp-evaluation-mm-llm-judge"></a>

Amazon Nova MM\$1LLM Judge라고 하는 멀티모달에 대한 Nova LLM 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` 데이터세트에 필요한 스키마 형식을 따라야 합니다.
+ 입력 데이터세트에서는 이미지 속성을 제외하고 모든 레코드가 12k 컨텍스트 길이 미만이 되도록 보장해야 합니다.

스키마 형식 - `.jsonl` 파일의 각 줄은 다음 필드가 있는 JSON 객체여야 합니다.
+ 필수 필드: 

  `prompt`: 생성된 응답에 대한 프롬프트가 포함된 문자열입니다.

  `images`: 데이터 속성(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는 지원되지 않습니다.
+ 입력 데이터세트에서는 이미지 속성을 제외하고 모든 레코드가 12k 컨텍스트 길이 미만이 되도록 보장해야 합니다.

## Rubric 기반 평가
<a name="nova-hp-evaluate-rubric-judge"></a>

Rubric Judge는 Amazon Nova 2.0 Lite에 빌드된 향상된 평가형 LLM 평가 모델입니다. 기본 설정 결정(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는 각 프롬프트에 맞게 조정된 사용자 지정 평가 기준을 동적으로 생성하고 여러 차원에 세분화된 점수를 할당합니다.

주요 기능:
+ **동적 기준 생성**: 입력 프롬프트를 기반으로 관련 평가 차원 자동 생성
+ **가중치 기반 점수**: 상대적 유의성을 반영하기 위해 각 기준에 중요도 가중치 할당
+ **세분화된 평가**: 각 기준에 대해 바이너리(true/false) 또는 스케일(1\$15) 기준으로 세부 점수 제공
+ **품질 지표**: 응답 간 차이의 정도를 정량화하는 연속 품질 점수(스케일: 0\$11) 계산

모델에서 생성된 기준 예제:

```
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)

### 레시피 구성
<a name="nova-hp-evaluate-rubric-judge-recipe"></a>

**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 레시피(비교용)**  
원래 평가 모델은 `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)
```

### 입력 데이터세트 형식
<a name="nova-hp-evaluate-rubric-judge-input"></a>

입력 데이터세트 형식은 [원래 결정 모델](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 객체여야 함
+ 항목을 새 줄로 구분
+ 예제와 같이 정확한 필드 이름 지정 준수

### 평가 출력
<a name="nova-hp-evaluate-rubric-judge-output"></a>

**출력 구조**  
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의 새 지표**  
다음과 같은 6개의 지표는 Rubric Judge에 고유하며 세분화된 품질 평가를 제공합니다.


| 지표 | 설명 | 
| --- |--- |
| weighted\$1score\$1A | 모델에서 생성된 모든 평가 기준에서 response\$1A에 대해 정규화된 평균 품질 점수. 점수에는 기준 중요도에 따라 가중치가 부여되고 점수는 0\$11의 스케일로 정규화됩니다(높은 값 = 더 나은 품질). | 
| weighted\$1score\$1A\$1stderr | weighted\$1score\$1A 평균의 표준 오차로, 통계적 불확실성을 나타냄 | 
| weighted\$1score\$1B | 모델에서 생성된 모든 평가 기준에서 response\$1B에 대해 정규화된 평균 품질 점수. 점수에는 기준 중요도에 따라 가중치가 부여되고 점수는 0\$11의 스케일로 정규화됩니다(높은 값 = 더 나은 품질). | 
| weighted\$1score\$1B\$1stderr | weighted\$1score\$1B 평균의 표준 오차로, 통계적 불확실성을 나타냄 | 
| score\$1margin | 가중치 적용 점수 간 차이(weighted\$1score\$1A - weighted\$1score\$1B로 계산됨). 범위: -1.0\$11.0. 양수 = response\$1A가 더 나음, 음수 = response\$1B가 더 나음, 0에 가까운 값 = 유사한 품질 | 
| score\$1margin\$1stderr | score\$1margin 평균의 표준 오차로, 품질 차이 측정의 불확실성을 나타냄 | 

**가중치 기반 점수 지표 이해**  
**목적**: 가중치 기반 점수는 바이너리 기본 설정 결정을 보완하는 지속적인 품질 측정을 제공하여 모델 성능에 대한 심층적인 인사이트를 제공합니다.

**원래 평가와의 주요 차이**:
+ **원래 평가**: 개별 기본 설정(A>B, B>A, A=B)만 출력
+ **Rubric Judge**: 사용자 지정 기준에 따라 기본 설정과 연속 품질 점수(스케일: 0\$11) 모두 출력

**Interpreting score\$1margin**:
+ `score_margin = -0.128`: Response\$1B 점수가 response\$1A보다 12.8% 더 높음
+ `|score_margin| < 0.1`: 품질 차이가 적음(근사한 결정)
+ `|score_margin| > 0.2`: 명확한 품질 차이(신뢰할 수 있는 결정)

**사용 사례**:
+ **모델 개선**: 모델 성능이 저하되는 특정 영역 식별
+ **품질 정량화**: 승률과 함께 성능 격차의 크기 측정
+ **신뢰도 평가**: 근사한 결정과 명확한 품질 차이 구분

**중요**  
최종 결정은 여전히 판단 모델의 명시적 기본 설정 레이블을 기반으로 하여 전체적인 추론을 보존하고 전진/후진 평가를 통해 적절한 위치 편향 완화를 보장합니다. 가중치 적용 점수는 기본 결정을 대체하는 것이 아니라 관찰성 도구 역할을 합니다.

**계산 방법**  
가중치 적용 점수는 다음 프로세스를 통해 계산됩니다.
+ **기준 데이터 추출**: 평가의 YAML 출력을 구문 분석하여 기준 점수 및 가중치 추출
+ **점수 정규화**:
  + 스케일 유형 기준(1\$15): `(score - 1) / 4`를 계산하여 0\$11로 정규화
  + 이진 기준(true/false): 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% 더 높음을 나타냅니다.

### 추론 모델 지원
<a name="nova-hp-evaluate-rubric-judge-reasoning"></a>

추론 모델 지원을 사용하면 최종 응답을 생성하기 전에 명시적인 내부 추론을 수행하는 추론 가능 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)
```

**reasoning\$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."`에서 실패함

**사용 가능한 옵션**:


| 옵션 | 동작 | 토큰 제한 | 사용 사례 | 
| --- |--- |--- |--- |
| null(기본값) | 추론 모드 비활성화 | 해당 사항 없음 | 추론 오버헤드가 없는 표준 평가 | 
| low | 제약 조건과의 추론 활성화 | 내부 추론을 위한 4,000개의 토큰 | 간결한 추론이 필요한 시나리오, 속도와 비용에 맞게 최적화 | 
| 높음 | 제약 조건 없이 추론 활성화 | 내부 추론에 대한 토큰 제한 없음 | 광범위한 분석 및 단계별 추론이 필요한 복잡한 문제 | 

**추론을 활성화하는 경우**  
**다음과 같은 경우 추론 모드(`low`, `medium` 또는 `high`)를 사용합니다.**
+ 복잡한 문제 해결 태스크(수학, 논리적 퍼즐, 코딩)
+ 중간 추론이 필요한 다단계 분석 질문
+ 자세한 설명 또는 단계별 사고로 정확도가 향상되는 태스크
+ 응답 품질이 속도보다 우선되는 시나리오

**다음과 같은 경우 비추론 모드(파라미터 생략)를 사용합니다.**
+ 간단한 Q&A 또는 실제 쿼리
+ 창의적 쓰기 태스크
+ 더 빠른 응답 시간이 중요한 경우
+ 추론 오버헤드를 제외해야 하는 성능 벤치마킹
+ 추론으로 태스크 성능이 개선되지 않는 경우 비용 최적화

**문제 해결**  
**오류: 'Reasoning mode is enabled but model does not support reasoning'**

**원인**: `reasoning_effort` 파라미터가 null이 아닌 값으로 설정되었지만 지정된 `model_type`에서 추론을 지원하지 않습니다.

**​해결 방법:**
+ 모델 유형이 `amazon.nova-2-lite-v1:0:256k`인지 확인
+ 다른 모델을 사용하는 경우 추론 가능 모델로 전환하거나 레시피에서 `reasoning_effort` 파라미터를 제거합니다.

# 평가 작업 시작
<a name="customize-fine-tune-evaluate-start-job"></a>

다음은 제안된 평가 인스턴스 유형 및 모델 유형 구성을 제공합니다.

```
# 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 클러스터 콘솔을 통해 작업 상태를 볼 수 있어야 합니다.

# 평가 결과 액세스 및 분석
<a name="customize-fine-tune-evaluate-access-results"></a>

평가 작업이 성공적으로 완료되면 이 섹션의 정보를 사용하여 결과를 액세스하고 분석할 수 있습니다. 레시피에 정의된 `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 - 모델에 제출된 최종 프롬프트
+ inference - 모델의 원시 추론 출력
+ gold - 입력 데이터세트의 대상 응답
+ metadata - 제공된 경우 입력 데이터세트의 메타데이터 문자열

Tensorboard에서 평가 지표를 시각화하려면 다음 단계를 완료하세요.

1. SageMaker AI Tensorboard로 이동합니다.

1. **S3 폴더**를 선택합니다.

1. S3 폴더 경로를 추가합니다. 예: `s3://output_path/job-name/eval-tensorboard-result/eval`

1. 동기화가 완료될 때까지 기다립니다.

시계열, 스칼라 및 텍스트 시각화를 사용할 수 있습니다.

다음 모범 사례를 따르는 것이 좋습니다.
+ 출력 경로를 모델 및 벤치마크 유형별로 정리하여 유지합니다.
+ 쉽게 추적할 수 있도록 일관된 이름 지정 규칙을 유지합니다.
+ 추출된 결과를 안전한 위치에 저장합니다.
+ TensorBoard 동기화 상태를 모니터링하여 데이터가 성공적으로 로드되었는지 확인합니다.

SageMaker HyperPod 작업 오류 로그는 CloudWatch 로그 그룹 `/aws/sagemaker/Clusters/cluster-id`에서 찾을 수 있습니다.

## 로그 확률 출력 형식
<a name="nova-hp-access-results-logprobs"></a>

`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 평가
<a name="nova-hp-evaluate-rft"></a>

**참고**  
자체 AWS 환경에서 원격 보상 함수를 통한 평가는 Amazon Nova Forge 고객인 경우에만 사용할 수 있습니다.

**중요**  
`rl_env` 구성 필드는 훈련이 아닌 평가에만 사용됩니다. 훈련 중에 `reward_lambda_arn`(싱글턴)을 사용하여 보상 함수를 구성하거나 `rollout.delegate: true`(멀티턴)를 사용하여 BYOO 인프라를 구성합니다.

**RFT 평가란 무엇인가요?**  
RFT 평가를 사용하면 강화 학습 훈련 이전, 도중 또는 이후에 사용자 지정 보상 함수를 통해 모델의 성능을 평가할 수 있습니다. 사전 정의된 지표를 사용하는 표준 평가와 달리, RFT 평가를 사용하면 특정 요구 사항에 따라 모델 출력의 점수를 계산하는 Lambda 함수를 통해 고유한 성공 기준을 정의할 수 있습니다.

**RFT로 평가하는 이유는 무엇인가요?**  
RL 미세 조정 프로세스에서 다음을 지원하는지 확인하려면 평가가 중요합니다.
+ 특정 사용 사례 및 인적 값에 맞게 모델 정렬 개선
+ 주요 태스크에 대한 모델 기능 유지 관리 또는 개선
+ 다른 태스크에서 사실성 감소, 세부성 증가 또는 성능 저하와 같은 의도하지 않은 부작용 방지
+ 보상 함수에 정의된 대로 사용자 지정 성공 기준 충족

**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)

## 데이터 형식 요구 사항
<a name="nova-hp-evaluate-rft-data-format"></a>

**입력 데이터 구조**  
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 객체 1개)
+ 모델 출력: 지정된 모델에서 생성된 완료를 대상으로 평가가 수행됨

## 평가 레시피 준비
<a name="nova-hp-evaluate-rft-recipe"></a>

**샘플 레시피 구성**  
다음 예제에서는 전체 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>
```

## 보상 함수 사전 설정
<a name="nova-hp-evaluate-rft-preset"></a>

RFT Lambda 함수에 쉽게 통합할 수 있도록 두 가지 사전 설정 보상 함수(`prime_code` 및 `prime_math`)를 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 Console에서 Lambda 함수에 계층 추가(사용자 지정 계층에서 preset-function-layer를 선택하고 numpy 종속성에서 AWSSDKPandas-Python312도 추가)

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"]}}
```

**주요 기능:**
+ 마크다운 코드 블록에서 자동 코드 추출
+ 함수 탐지 및 직접 호출 기반 테스트
+ 제한 시간 보호를 사용하는 테스트 사례 실행
+ 구문 검증 및 컴파일 검사
+ 트레이스백을 사용하는 세부 오류 보고

**prime\$1math 함수**  
**용도**: 기호 수학 지원을 통해 수학 추론 및 문제 해결 기능을 평가합니다.

**입력 형식**:

```
{"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"}
```

**주요 기능:**
+ SymPy를 사용하는 기호 수학 평가
+ 여러 응답 형식(LaTeX, 일반 텍스트, 기호)
+ 수학적 동등성 검사
+ 표현식 정규화 및 단순화

**모범 사례**  
사전 설정된 보상 함수를 사용할 때 다음 모범 사례를 따릅니다.
+ 테스트 사례에서 적절한 데이터 유형 사용(정수 대 문자열, 부울 대 'True')
+ 코드 문제에서 명확한 함수 서명 제공
+ 테스트 입력에서 엣지 케이스 포함(0, 음수, 빈 입력)
+ 참조 답변에서 일관된 수학 표현식 형식 지정
+ 배포 전에 샘플 데이터를 사용하여 보상 함수 테스트

## 보상 함수 생성
<a name="nova-hp-evaluate-rft-create-function"></a>

**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\$11.0)
+ `metrics_list`: 다음을 포함하는 개별 지표의 배열:
  + `name`: 지표 식별자(예: 'accuracy', 'fluency')
  + `value`: 지표 점수(일반적으로 0.0\$11.0)
  + `type`: 'Metric'(보고용) 또는 'Reward'(훈련에 사용됨)

## IAM 권한
<a name="nova-hp-evaluate-rft-iam"></a>

**필수 권한**  
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 실행 역할에 추가합니다.

## 평가 작업 실행
<a name="nova-hp-evaluate-rft-execution"></a>

1. **데이터 준비**
   + 데이터 형식 요구 사항에 따라 평가 데이터 형식 지정
   + Amazon S3에 JSON 파일(`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 로그: 보상 함수 문제 디버깅

## 평가 결과 이해
<a name="nova-hp-evaluate-rft-results"></a>

**출력 형식**  
평가 작업은 결과를 지정된 Amazon S3 위치에 JSONL 형식으로 출력합니다. 각 줄에는 하나의 샘플에 대한 평가 결과가 포함됩니다.

```
{
  "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(최저)\$11.0(최상)이지만 구현에 따라 다름
+ 용도: 전체 성능을 요약하는 단일 숫자
+ 사용법: 모델 비교, 훈련 대비 개선 추적

**개별 지표**:
+ 지표 유형: 분석을 위한 정보용 지표
+ 보상 유형: RFT 훈련 도중 사용되는 지표
+ 해석: 반대 지표를 설계하지 않는 한, 값이 높을수록 일반적으로 더 나은 성능을 나타냄

**성능 벤치마크**  
'양호'한 성능을 구성하는 요소는 사용 사례에 따라 달라집니다.


| 점수 범위 | 해석 | 작업 | 
| --- |--- |--- |
| 0.8 - 1.0 | 우수 | 배포 준비된 모델 | 
| 0.6\$10.8 | 양호 | 약간의 개선이 도움이 될 수 있음 | 
| 0.4\$10.6 | 공정 | 상당한 개선이 필요함 | 
| 0.0\$10.4 | 열악 | 훈련 데이터 및 보상 함수 검토 | 

**중요**  
다음은 일반적인 지침입니다. 비즈니스 요구 사항, 기준 모델 성능, 도메인별 제약 조건 및 추가 훈련의 비용 편익 분석을 기반으로 자체 임계치를 정의합니다.