Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

RFT-Bewertung

Was ist eine RFT-Evaluierung?

Die RFT-Evaluierung ermöglicht es Ihnen, die Leistung Ihres Modells mithilfe benutzerdefinierter Belohnungsfunktionen vor, während oder nach dem Reinforcement-Learning-Training zu bewerten. Im Gegensatz zu Standardevaluationen, die vordefinierte Metriken verwenden, können Sie mit der RFT-Evaluierung Ihre eigenen Erfolgskriterien mithilfe einer Lambda-Funktion definieren, die die Modellergebnisse anhand Ihrer spezifischen Anforderungen bewertet.

Warum mit RFT evaluieren?

Die Bewertung ist entscheidend, um festzustellen, ob der RL-Feinabstimmungsprozess Folgendes beinhaltet:

Wann sollte die RFT-Evaluierung verwendet werden

Verwenden Sie die RFT-Evaluierung in diesen Szenarien:

Datenformatanforderungen

Struktur der Eingabedaten

Die Eingabedaten der RFT-Evaluierung müssen dem OpenAI Reinforcement Fine-Tuning Format folgen. Jedes Beispiel ist ein JSON-Objekt, das Folgendes enthält:

Beispiel für ein Datenformat

Das folgende Beispiel zeigt das erforderliche Format:

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

Aktuelle Einschränkungen

Die folgenden Einschränkungen gelten für die RFT-Evaluierung:

Vorbereitung Ihres Bewertungsrezepts

Konfiguration eines Beispielrezepts

Das folgende Beispiel zeigt ein vollständiges RFT-Evaluierungsrezept:

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>

Voreingestellte Belohnungsfunktionen

Zwei voreingestellte Belohnungsfunktionen (prime_codeundprime_math) sind als Lambda-Layer für die einfache Integration in Ihre RFT-Lambda-Funktionen verfügbar.

-Übersicht

Diese voreingestellten Funktionen bieten sofort einsatzbereite Evaluierungsfunktionen für:

Quick Setup

Um voreingestellte Belohnungsfunktionen zu verwenden:

prime_code-Funktion

Zweck: Evaluiert Python-Codegenerierungsaufgaben, indem Code anhand von Testfällen ausgeführt und die Richtigkeit gemessen wird.

Beispiel für ein Eingabedatensatzformat aus der Auswertung:

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

Die wichtigsten Funktionen:

prime_math-Funktion

Zweck: Evaluiert mathematische Denk- und Problemlösungsfähigkeiten mit symbolischer mathematischer Unterstützung.

Eingabeformat:

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

Die wichtigsten Funktionen:

Bewährte Methoden

Folgen Sie diesen bewährten Methoden, wenn Sie voreingestellte Belohnungsfunktionen verwenden:

Erstellen Sie Ihre Belohnungsfunktion

Lambda-ARN

Für den Lambda-ARN müssen Sie sich auf das folgende Format beziehen:

"arn:aws:lambda:*:*:function:*SageMaker*"

Wenn das Lambda dieses Benennungsschema nicht hat, schlägt der Job mit diesem Fehler fehl:

[ERROR] Unexpected error: lambda_arn must contain one of: ['SageMaker', 'sagemaker', 'Sagemaker'] when running on SMHP platform (Key: lambda_arn)

Struktur der Lambda-Funktion

Ihre Lambda-Funktion empfängt Stapel von Modellausgaben und gibt Belohnungswerte zurück. Im Folgenden finden Sie eine Beispielimplementierung:

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-Anforderungsformat

Ihre Lambda-Funktion empfängt Daten in diesem Format:

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

Lambda-Antwortformat

Ihre Lambda-Funktion muss Daten in diesem Format zurückgeben:

[
  {
    "id": "sample-001",
    "aggregate_reward_score": 0.75,
    "metrics_list": [
      {
        "name": "accuracy",
        "value": 0.85,
        "type": "Metric"
      },
      {
        "name": "fluency",
        "value": 0.90,
        "type": "Reward"
      }
    ]
  }
]

Antwortfelder:

IAM-Berechtigungen

Erforderliche Berechtigungen

Ihre SageMaker KI-Ausführungsrolle muss über Berechtigungen zum Aufrufen Ihrer Lambda-Funktion verfügen. Fügen Sie diese Richtlinie zu Ihrer SageMaker AI-Ausführungsrolle hinzu:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "lambda:InvokeFunction"
      ],
      "Resource": "arn:aws:lambda:region:account-id:function:function-name"
    }
  ]
}

Lambda-Ausführungsrolle

Für die Ausführungsrolle Ihrer Lambda-Funktion sind grundlegende Lambda-Ausführungsberechtigungen erforderlich:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents"
      ],
      "Resource": "arn:aws:logs:*:*:*"
    }
  ]
}

Zusätzliche Berechtigungen: Wenn Ihre Lambda-Funktion auf andere AWS Dienste zugreift (z. B. Amazon S3 für Referenzdaten, DynamoDB für die Protokollierung), fügen Sie diese Berechtigungen der Lambda-Ausführungsrolle hinzu.

Ausführung des Evaluierungsauftrags

Evaluierungsergebnisse verstehen

Ausgabeformat

Der Evaluierungsauftrag gibt die Ergebnisse im JSONL-Format an Ihren angegebenen Amazon S3-Standort aus. Jede Zeile enthält die Bewertungsergebnisse für eine Stichprobe:

{
  "id": "sample-001",
  "aggregate_reward_score": 0.75,
  "metrics_list": [
    {
      "name": "accuracy",
      "value": 0.85,
      "type": "Metric"
    },
    {
      "name": "fluency",
      "value": 0.90,
      "type": "Reward"
    }
  ]
}

Interpretation der Ergebnisse

Gesamter Belohnungspunktestand:

Individuelle Metriken:

Leistungs-Benchmarks

Was eine „gute“ Leistung ausmacht, hängt von Ihrem Anwendungsfall ab: