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

Was ist RFT-Evaluierung?

Mit der RFT-Evaluierung können Sie die Leistung Ihres Modells mithilfe benutzerdefinierter Belohnungsfunktionen vor, während oder nach dem Reinforcement-Learning-Training bewerten. Im Gegensatz zu Standardbewertungen, die vordefinierte Metriken verwenden, können Sie mit RFT Evaluation Ihre eigenen Erfolgskriterien mithilfe einer Lambda-Funktion definieren, die Modellergebnisse auf der Grundlage 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 RFT Evaluation in diesen Szenarien:

Datenformatanforderungen

Struktur der Eingabedaten

Die Eingabedaten der RFT-Bewertung müssen dem OpenAI Reinforcement Fine-Tuning-Format entsprechen. 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
  }
}

Derzeitige Einschränkungen

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

Vorbereitung Ihres Bewertungsrezepts

Beispiel für eine Rezeptkonfiguration

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

Wir haben 2 voreingestellte Belohnungsfunktionen (prime_code, prime_math) aus der Open-Source-Verl-Bibliothek in einer Lambda-Schicht zur Verfügung gestellt, die Sie einfach mit Ihrem RFT-Lambda bündeln können, um es zu verwenden.

-Übersicht

out-of-the-boxDiese voreingestellten Funktionen bieten Evaluierungsmöglichkeiten für:

Quick Setup

Um voreingestellte Belohnungsfunktionen zu verwenden:

prime_code-Funktion

Zweck: Evaluiert Aufgaben zur Python-Codegenerierung, 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"]}}

Hauptmerkmale:

prime_math-Funktion

Zweck: Evaluiert die Fähigkeiten zum mathematischen Denken und zur Problemlösung mit Unterstützung symbolischer Mathematik.

Eingabeformat:

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

Die wichtigsten Funktionen:

Best Practices

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

Erstellen Sie Ihre Belohnungsfunktion

Lambda-ARN

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

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

Wenn das Lambda dieses Benennungsschema nicht hat, schlägt der Job mit dem folgenden 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 Prämienwerte zurück. Im Folgenden finden Sie ein Beispiel für eine Implementierung:

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

Die Ausführungsrolle Ihrer Lambda-Funktion benötigt grundlegende Lambda-Ausführungsberechtigungen:

{
  "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 Evaluierungsjobs

Evaluierungsergebnisse verstehen

Ausgabeformat

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

{
  "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 Prämienwert:

Individuelle Metriken:

Leistungsmaßstäbe

Was unter „guter“ Leistung zu verstehen ist, hängt von Ihrem Anwendungsfall ab: