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 **Anmerkung** Die Bewertung über Remote-Prämienfunktionen in Ihrer eigenen AWS Umgebung ist nur verfügbar, wenn Sie Kunde von Amazon Nova Forge sind. **Wichtig** Das `rl_env` Konfigurationsfeld wird ausschließlich zur Evaluierung verwendet, nicht für Schulungen. Während des Trainings konfigurieren Sie Belohnungsfunktionen mithilfe einer `reward_lambda_arn` (Single-Turn) oder einer BYOO-Infrastruktur mit `rollout.delegate: true` (Multi-Turn). **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: + Verbesserte Abstimmung des Modells auf Ihren spezifischen Anwendungsfall und Ihre menschlichen Werte + Beibehaltung oder Verbesserung der Modellfunktionen bei wichtigen Aufgaben + Vermeidung unbeabsichtigter Nebenwirkungen wie verringerte Sachlichkeit, erhöhte Ausführlichkeit oder Leistungseinbußen bei anderen Aufgaben + Hat Ihre benutzerdefinierten Erfolgskriterien erfüllt, wie sie in Ihrer Belohnungsfunktion definiert sind **Wann sollte die RFT-Evaluierung verwendet werden** Verwenden Sie RFT Evaluation in diesen Szenarien: + Vor dem RFT-Training: Legen Sie Basiskennzahlen für Ihren Bewertungsdatensatz fest + Während des RFT-Trainings: Überwachen Sie den Trainingsfortschritt mit Zwischenstationen + Nach dem RFT-Training: Stellen Sie sicher, dass das endgültige Modell Ihren Anforderungen entspricht + Modelle vergleichen: Evaluieren Sie mehrere Modellversionen anhand einheitlicher Prämienkriterien **Anmerkung** Verwenden Sie RFT Evaluation, wenn Sie benutzerdefinierte, domänenspezifische Metriken benötigen. Verwenden Sie für allgemeine Bewertungsmethoden (Genauigkeit, Verwirrung, BLEU) die Standardauswertungsmethoden. **Topics** + [Datenformatanforderungen](#nova-hp-evaluate-rft-data-format) + [Vorbereitung Ihres Bewertungsrezepts](#nova-hp-evaluate-rft-recipe) + [Voreingestellte Belohnungsfunktionen](#nova-hp-evaluate-rft-preset) + [Erstellen Sie Ihre Belohnungsfunktion](#nova-hp-evaluate-rft-create-function) + [IAM-Berechtigungen](#nova-hp-evaluate-rft-iam) + [Ausführung des Evaluierungsjobs](#nova-hp-evaluate-rft-execution) + [Evaluierungsergebnisse verstehen](#nova-hp-evaluate-rft-results) ## 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: + `messages`: Eine Reihe von Konversationswechseln mit `system` und Rollen `user` + Optionale weitere Metadaten, z. B. reference\_answer **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\": }. Equation: 2x + 5 = 13" } ] } ], "reference_answer": { "x": 4 } } ``` **Derzeitige Einschränkungen** Die folgenden Einschränkungen gelten für die RFT-Evaluierung: + Nur Text: Es werden keine multimodalen Eingaben (Bilder, Audio, Video) unterstützt + Single-Turn-Konversationen: Unterstützt nur Einzelbenutzernachrichten (keine Multi-Turn-Dialoge) + JSON-Format: Die Eingabedaten müssen im JSONL-Format vorliegen (ein JSON-Objekt pro Zeile) + Modellausgaben: Die Auswertung erfolgt anhand der generierten Vervollständigungen aus dem angegebenen Modell ## 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 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:::function: ``` ## Voreingestellte Belohnungsfunktionen Zwei voreingestellte Belohnungsfunktionen (`prime_code`und`prime_math`) sind als Lambda-Schicht für eine einfache Integration in Ihre RFT-Lambda-Funktionen verfügbar. **-Übersicht** Diese voreingestellten Funktionen bieten out-of-the-box Evaluierungsfunktionen für: + **prime\_code: Codegenerierung** und Korrektheitsbewertung + **prime\_math**: Mathematisches Denken und Bewertung der Problemlösung **Quick Setup** Um voreingestellte Belohnungsfunktionen zu verwenden: 1. [Laden Sie die Lambda-Schicht aus den nova-custom-eval-sdk Versionen herunter](https://github.com/aws/nova-custom-eval-sdk/releases) 1. Veröffentlichen Sie die Lambda-Schicht mit AWS CLI: ``` 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. Fügen Sie die Ebene zu Ihrer Lambda-Funktion in der AWS Konsole hinzu (Wählen Sie die Ebene preset-function-layer aus der benutzerdefinierten Ebene aus und fügen Sie AWSSDKPandas-Python 312 für numpy-Abhängigkeiten hinzu) 1. Importieren und in Ihrem Lambda-Code verwenden: ``` from prime_code import compute_score # For code evaluation from prime_math import compute_score # For math evaluation ``` **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**: + Automatische Codeextraktion aus Markdown-Codeblöcken + Funktionserkennung und anrufbasiertes Testen + Ausführung von Testfällen mit Timeout-Schutz + Syntaxvalidierung und Kompilierungsprüfungen + Detaillierte Fehlerberichterstattung mit Tracebacks **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**: + Symbolische mathematische Bewertung mit SymPy + Mehrere Antwortformate (LaTeX, Klartext, symbolisch) + Mathematische Äquivalenzprüfung + Normalisierung und Vereinfachung von Ausdrücken **Best Practices** Folgen Sie diesen bewährten Methoden, wenn Sie voreingestellte Belohnungsfunktionen verwenden: + Verwenden Sie in Testfällen die richtigen Datentypen (Ganzzahlen im Vergleich zu Zeichenketten, boolesche Werte im Vergleich zu „True“) + Stellen Sie bei Codeproblemen klare Funktionssignaturen bereit + Schließen Sie Grenzfälle in Testeingaben ein (Null, negative Zahlen, leere Eingaben) + Formatieren Sie mathematische Ausdrücke konsistent in Referenzantworten + Testen Sie Ihre Belohnungsfunktion vor der Bereitstellung mit Beispieldaten ## 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." } } ] ``` **Anmerkung** Die Nachrichtenstruktur umfasst das verschachtelte `content` Array, das dem Eingabedatenformat entspricht. Die letzte Nachricht mit Rolle `nova_assistant` enthält die vom Modell generierte Antwort. **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**: + `id`: Muss mit der eingegebenen Proben-ID übereinstimmen + `aggregate_reward_score`: Gesamtpunktzahl (normalerweise 0,0 bis 1,0) + `metrics_list`: Array einzelner Metriken mit: + `name`: Kennzahl der Metrik (z. B. „Genauigkeit“, „Fließfähigkeit“) + `value`: Metrischer Wert (typischerweise 0,0 bis 1,0) + `type`: Entweder „Metrik“ (für Berichte) oder „Belohnung“ (wird in Schulungen verwendet) ## 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 1. **Bereiten Sie Ihre Daten vor** + Formatieren Sie Ihre Bewertungsdaten gemäß den Anforderungen an das Datenformat + Laden Sie Ihre JSONL-Datei auf Amazon S3 hoch: `s3://your-bucket/eval-data/eval_data.jsonl` 1. **Konfiguriere dein Rezept** Aktualisieren Sie das Beispielrezept mit Ihrer Konfiguration: + Stellen Sie `model_name_or_path` den Standort Ihres Modells ein + Stellen `lambda_arn` Sie Ihre Belohnungsfunktion ARN ein + Stellen `output_s3_path` Sie den gewünschten Ausgabeort ein + Passen Sie die `inference` Parameter nach Bedarf an Speichern Sie das Rezept unter `rft_eval_recipe.yaml` 1. **Führen Sie die Evaluierung aus** Führen Sie den Evaluierungsjob mit dem mitgelieferten Notizbuch aus: [Evaluationsnotizbuch für das Nova-Modell](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook) 1. **Überwachen Sie den Fortschritt** Überwachen Sie Ihre Bewertungsaufgabe durch: + SageMaker KI-Konsole: Überprüfen Sie den Auftragsstatus und die Protokolle + CloudWatch Protokolle: Detaillierte Ausführungsprotokolle anzeigen + Lambda Logs: Probleme mit der Belohnungsfunktion debuggen ## Evaluierungsergebnisse verstehen **Ausgabeformat** Der Evaluierungsjob 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" } ] } ``` **Anmerkung** Die Ausgabe des RFT-Evaluierungsjobs ist identisch mit dem Lambda Response-Format. Der Bewertungsservice durchläuft die Antwort Ihrer Lambda-Funktion unverändert und gewährleistet so die Konsistenz zwischen Ihren Belohnungsberechnungen und den Endergebnissen. **Interpretation der Ergebnisse** **Gesamter Prämienwert**: + Bereich: Normalerweise 0,0 (am schlechtesten) bis 1,0 (am besten), hängt jedoch von Ihrer Implementierung ab + Zweck: Eine einzelne Zahl, die die Gesamtleistung zusammenfasst + Verwendungszweck: Modelle vergleichen, Verbesserungen im Vergleich zu Schulungen verfolgen **Individuelle Metriken**: + Metriktyp: Informationsmetriken für die Analyse + Art der Belohnung: Metriken, die während des RFT-Trainings verwendet wurden + Interpretation: Höhere Werte bedeuten im Allgemeinen eine bessere Leistung (es sei denn, Sie entwerfen inverse Metriken) **Leistungs-Benchmarks** Was unter „guter“ Leistung zu verstehen ist, hängt von Ihrem Anwendungsfall ab: | Punktebereich | Interpretation | Action | | --- |--- |--- | | 0,8 - 1,0 | Ausgezeichnet | Modell bereit für den Einsatz | | 0,6 - 0,8 | Gut | Geringfügige Verbesserungen können von Vorteil sein | | 0,4 - 0,6 | Fair | Signifikante Verbesserung erforderlich | | 0,0 - 0,4 | Schlecht | Überprüfen Sie die Trainingsdaten und die Belohnungsfunktion | **Wichtig** Dies sind allgemeine Richtlinien. Definieren Sie Ihre eigenen Schwellenwerte auf der Grundlage der Geschäftsanforderungen, der Leistung des Basismodells, der domänenspezifischen Einschränkungen und der Kosten-Nutzen-Analyse von Weiterbildungsmaßnahmen.