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.
# Evaluieren Sie Ihr SageMaker KI-trainiertes Modell
Der Zweck des Bewertungsprozesses besteht darin, die Leistung des trainierten Modells anhand von Benchmarks oder benutzerdefinierten Datensätzen zu bewerten. Der Bewertungsprozess umfasst in der Regel Schritte zur Erstellung eines Bewertungsrezepts, das auf das trainierte Modell verweist, zur Festlegung von Bewertungsdatensätzen und -metriken, zur Einreichung eines separaten Jobs für die Bewertung und zur Bewertung anhand von Standardbenchmarks oder benutzerdefinierten Daten. Der Bewertungsprozess gibt Leistungsmetriken aus, die in Ihrem Amazon-S3-Bucket gespeichert sind.
**Anmerkung**
Der in diesem Thema beschriebene Bewertungsprozess ist ein Offline-Prozess. Das Modell wird anhand festgelegter Benchmarks mit vordefinierten Antworten getestet, statt in Echtzeit oder anhand von Live-Benutzerinteraktionen bewertet zu werden. Zur Evaluierung in Echtzeit können Sie das Modell testen, nachdem es auf Amazon Bedrock bereitgestellt wurde, indem Sie Amazon Bedrock [Runtime](https://docs.aws.amazon.com//bedrock/latest/userguide/import-with-create-custom-model.html) aufrufen. APIs
**Topics**
+ [Voraussetzungen](#nova-model-evaluation-prerequisites)
+ [Verfügbare Benchmark-Aufgaben](#nova-model-evaluation-benchmark)
+ [Bewertung spezifischer Konfigurationen](#nova-model-evaluation-config)
+ [Ausführen von Bewertungs-Trainingsjobs](#nova-model-evaluation-notebook)
+ [Auswertung und Analyse der Bewertungsergebnisse](#nova-model-evaluation-assess)
+ [Bewährte Methoden zur Bewertung und Problembehebung](#nova-model-evaluation-best-practices)
+ [Verfügbare Unteraufgaben](#nova-model-evaluation-subtasks)
+ [Bewertung des Argumentationsmodells](nova-reasoning-model-evaluation.md)
+ [RFT-Evaluierung](nova-rft-evaluation.md)
+ [Implementierung von Belohnungsfunktionen](nova-implementing-reward-functions.md)
## Voraussetzungen
Bevor Sie einen Bewertungs-Trainingsjob beginnen, sollten Sie Folgendes beachten.
+ Ein SageMaker KI-trainiertes Amazon Nova-Modell, dessen Leistung Sie bewerten möchten.
+ Amazon-Nova-Basisrezept zur Bewertung Weitere Informationen finden Sie unter [Abrufen von Amazon-Nova-Rezepten](nova-model-recipes.md#nova-model-get-recipes).
## Verfügbare Benchmark-Aufgaben
Es ist ein Beispielcodepaket verfügbar, das zeigt, wie Benchmark-Metriken mithilfe der SageMaker KI-Modellbewertungsfunktion für Amazon Nova berechnet werden. Informationen zum Zugriff auf die Codepakete finden Sie unter [Sample-n ova-lighteval-custom-task](https://github.com/aws-samples/sample-Nova-lighteval-custom-task/).
Hier finden Sie eine Liste unterstützter, verfügbarer Industriestandard-Benchmarks. Sie können die folgenden Benchmarks für den Parameter `eval_task` angeben.
**Verfügbare Benchmarks für die Modellbewertung**
| Benchmark | Modalität | Description | Kennzahlen | Strategie | Unteraufgabe verfügbar |
| --- | --- | --- | --- | --- | --- |
| mmlu | Text | Sprachverständnis für mehrere Aufgaben – testet Wissen in 57 Themen. | Richtigkeit | zs\$1cot | Ja |
| mmlu\$1pro | Text | MMLU – professioneller Bereich – konzentriert sich auf Fachbereiche wie Recht, Medizin, Rechnungswesen und Ingenieurwesen. | Richtigkeit | zs\$1cot | Nein |
| bbh | Text | Fortschrittliche Argumentationsaufgaben – eine Sammlung herausfordernder Probleme, die kognitive Fähigkeiten und Fähigkeiten zur Problemlösung auf höherem Niveau auf die Probe stellen. | Richtigkeit | fs\$1cot | Ja |
| gpqa | Text | Beantwortung allgemeiner Fragen zur Physik – beurteilt das Verständnis physikalischer Konzepte und die damit verbundenen Fähigkeiten zur Problemlösung. | Richtigkeit | zs\$1cot | Nein |
| math | Text | Mathematische Problemlösung – bewertet mathematische Überlegungen in verschiedenen Themenbereichen wie Algebra, Infinitesimalrechnung und Textaufgaben. | exact\$1match | zs\$1cot | Ja |
| strong\$1reject | Text | Aufgabe zur Qualitätskontrolle – Testet die Fähigkeit des Modells, unangemessene, schädliche oder falsche Inhalte zu erkennen und abzulehnen. | deflection | zs | Ja |
| ifeval | Text | Bewertung der Anweisungsbefolgung – Prüft, wie genau ein Modell die Anweisungen befolgt und die Aufgaben gemäß den Spezifikationen ausführt. | Richtigkeit | zs | Nein |
| gen\$1qa | Multimodal (Bild) | Auswertung benutzerdefinierter Datensätze — Ermöglicht es Ihnen, Ihren eigenen Datensatz für das Benchmarking bereitzustellen und die Modellergebnisse mit Referenzantworten anhand von Metriken wie ROUGE und BLEU zu vergleichen. `gen_qa`unterstützt Bildinferenz für Modelle, die auf Amazon Nova Lite oder Amazon Nova Pro basieren. Unterstützt auch Bring-Your-Own Metrics Lambda. (Verwenden Sie für die RFT-Evaluierung bitte das RFT-Eval-Rezept) | all | gen\$1qa | Nein |
| mmmu | Multimodal | Massive Multidiscipline Multimodal Understanding (MMMU) — Benchmark auf Hochschulniveau, bestehend aus Multiple-Choice-Fragen und offenen Fragen aus 30 Disziplinen.) | Richtigkeit | zs\$1cot | Ja |
| llm\$1judge | Text | LLM-as-a-Judge Präferenzvergleich — Verwendet ein Nova Judge-Modell, um die Präferenz zwischen Antwortpaaren (B im Vergleich zu A) für Ihre Eingabeaufforderungen zu ermitteln und die Wahrscheinlichkeit zu berechnen, dass B gegenüber A bevorzugt wird. | all | judge | Nein |
| mm\$1llm\$1judge | Multimodal (Bild) | Dieser neue Benchmark verhält sich genauso wie der obige textbasierte `llm_judge` Benchmark. Der einzige Unterschied besteht darin, dass er Bildinferenz unterstützt. | all | judge | Nein |
| rubric\$1llm\$1judge | Text | Rubric Judge ist ein erweitertes LLM-as-a-judge Evaluierungsmodell, das auf Nova 2.0 Lite basiert. Im Gegensatz zum [ursprünglichen Richtermodell](https://aws.amazon.com/blogs/machine-learning/evaluating-generative-ai-models-with-amazon-nova-llm-as-a-judge-on-amazon-sagemaker-ai/), das nur Präferenzurteile vorsieht, generiert Rubric Judge dynamisch benutzerdefinierte Bewertungskriterien, die auf jede Aufforderung zugeschnitten sind, und weist detaillierte Bewertungen für mehrere Dimensionen zu. | all | judge | Nein |
| aime\$12024 | Text | AIME 2024 — Prüfungsaufgaben auf Einladung der American Invitational Mathematics zur Prüfung von fortgeschrittenem mathematischen Denken und Problemlösen | exact\$1match | zs\$1cot | Nein |
| Calendar\$1Scheduling | Text | Natural Plan — Kalendar Scheduling — Aufgabe zum Testen von Planungsfunktionen für die Planung von Besprechungen für mehrere Tage und Personen | exact\$1match | fs | Nein |
| humaneval | Text | HumanEval - Ein Benchmark-Datensatz zur Bewertung der Fähigkeiten zur Codegenerierung großer Sprachmodelle | pass@1 | zs | Nein |
## Bewertung spezifischer Konfigurationen
Im Folgenden finden Sie eine Aufschlüsselung der wichtigsten Komponenten des Rezepts sowie Anleitungen dazu, wie Sie sie für Ihre Anwendungsfälle modifizieren können.
### Verstehen und Ändern Ihrer Rezepte
**Allgemeine Laufkonfiguration**
```
run:
name: eval_job_name
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
replicas: 1
data_s3_path: ""
mlflow_tracking_uri: ""
mlflow_experiment_name : ""
mlflow_run_name : ""
```
+ `name`: ein beschreibender Name für Ihren Bewertungsjob
+ `model_type`: gibt die zu verwendende Nova-Modellvariante an. Ändern Sie dieses Feld nicht manuell. Zu den Optionen gehören:
+ Amazon. nova-micro-v1:0:128 k
+ Amazonas. nova-lite-v1:0:300 k
+ Amazonas. nova-pro-v1:0:300 k
+ amazon.nova-2-lite-v 1:0:256 k
+ `model_name_or_path`: der Pfad zum Basismodell oder zum S3-Pfad für den Checkpoint nach dem Training. Zu den Optionen gehören:
+ nova-micro/prod
+ nova-lite/prod
+ nova-pro/prod
+ nova-lite-2/prod
+ S3-Pfad für den Checkpoint-Pfad nach dem Training (`s3:customer-escrow-111122223333-smtj-/`)
**Anmerkung**
**Bewerten eines trainierten Modells**
Um ein trainiertes Modell nach einem Nova-SFT-Trainingsjob zu bewerten, gehen Sie nach der Ausführung eines erfolgreichen Trainingsjobs wie folgt vor. Am Ende der Trainingsprotokolle wird die Protokollmeldung „Training ist abgeschlossen“ angezeigt. In Ihrem Ausgabe-Bucket befindet sich auch eine `manifest.json`-Datei, die den Speicherort Ihres Checkpoints enthält. Diese Datei befindet sich in einer `output.tar.gz`-Datei an Ihrem S3-Ausgabeort. Um mit der Bewertung fortzufahren, verwenden Sie diesen Checkpoint, indem Sie ihn in Ihrer Rezeptkonfiguration als Wert für `run.model_name_or_path` festlegen.
+ `replica`: Die Anzahl der Recheninstanzen, die für verteilte Inferenz (Ausführung von Inferenzen über mehrere Knoten) verwendet werden sollen. Stellen Sie einen `replica` Wert auf > 1 ein, um Inferenz mit mehreren Knoten zu aktivieren, was die Auswertung beschleunigt. Wenn `instance_count` sowohl als auch angegeben `replica` sind, `instance_count` hat dies Vorrang. Beachten Sie, dass mehrere Replikate nur für SageMaker KI-Schulungsjobs gelten, nicht.
+ `data_s3_path`: der Amazon-S3-Pfad für den Eingabedatensatz. Dieses Feld ist erforderlich, sollte aber immer leer bleiben.
+ `mlflow_tracking_uri`: (Optional) Der Standort des MLflow Tracking-Servers (nur auf SMHP erforderlich)
+ `mlflow_experiment_name`: (Optional) Name des Experiments zur Gruppierung verwandter ML-Läufe
+ `mlflow_run_name`: (Optional) Benutzerdefinierter Name für einen bestimmten Trainingslauf innerhalb eines Experiments
**Bewertungskonfiguration**
```
evaluation:
task: mmlu
strategy: zs_cot
subtask: abstract_algebra
metric: accuracy
```
+ `task`: gibt den Bewertungs-Benchmark oder die zu verwendende Aufgabe an. Die unterstützte Aufgabe umfasst:
+ `mmlu`
+ `mmlu_pro`
+ `bbh`
+ `gpqa`
+ `math`
+ `strong_reject`
+ `gen_qa`
+ `ifeval`
+ `mmmu`
+ `llm_judge`
+ `mm_llm_judge`
+ `rubric_llm_judge`
+ `aime_2024`
+ `calendar_scheduling`
+ `humaneval`
+ `strategy`: definiert den Bewertungsansatz.
+ `zs_cot`: Zero-shot Chain of Thought — ein Ansatz zur Entwicklung umfangreicher Sprachmodelle, der zum Nachdenken anregt, ohne dass step-by-step explizite Beispiele erforderlich sind.
+ `fs_cot`: Gedankenkette mit wenigen Klicks — ein Ansatz, bei dem zunächst einige step-by-step Argumentationsbeispiele vorgestellt werden, bevor das Modell aufgefordert wird, ein neues Problem zu lösen.
+ `zs`: Zero-shot – ein Ansatz zur Lösung eines Problems ohne vorherige Trainingsbeispiele
+ `gen_qa`: spezifische Strategie für die Verwendung eines eigenen Datensatzes
+ `judge`: Spezifische Strategie für Nova LLM als Richterin und. `mm_llm_judge`
+ `subtask`: Optional. Spezifische Komponenten der Bewertungsaufgabe. Eine vollständige Liste der verfügbaren Unteraufgaben finden Sie unter [Verfügbare Unteraufgaben](#nova-model-evaluation-subtasks).
+ Informationen zu den unterstützten Unteraufgaben finden Sie unter „Verfügbare Benchmark-Aufgaben“.
+ Sie sollten dieses Feld entfernen, wenn es keine Benchmark-Unteraufgaben gibt.
+ `metric`: die zu verwendende Bewertungsmetrik
+ `accuracy`: Prozentsatz der richtigen Antworten
+ `exact_match`: (für math-Benchmark) gibt die Rate zurück, mit der die eingegebenen vorhergesagten Zeichenketten exakt mit ihren Referenzen übereinstimmen.
+ `deflection`: gibt bei einem Benchmark mit starker Ablehnung die relative Abweichung vom Basismodell und die Differenz der Signifikanzmetriken zurück.
+ `all`:
Gibt für `gen_qa` und das Benchmarking mit eigenem Datensatz die folgenden Metriken zurück:
+ `rouge1`: misst die Überlappung von Unigrammen (einzelnen Wörtern) zwischen generiertem Text und Referenztext.
+ `rouge2`: misst die Überlappung von Bigrammen (zwei aufeinanderfolgenden Wörtern) zwischen generiertem Text und Referenztext.
+ `rougeL`: misst die längste gemeinsame Teilsequenz zwischen Texten und berücksichtigt Lücken beim Abgleich.
+ `exact_match`: binärer Wert (0 oder 1), der angibt, ob der generierte Text Zeichen für Zeichen exakt mit dem Referenztext übereinstimmt
+ `quasi_exact_match`: ähnlich wie Exact Match, aber weniger strikt, wobei in der Regel Unterschiede zwischen Groß- und Kleinschreibung, Zeichensetzung und Leerzeichen ignoriert werden
+ `f1_score`: harmonisches Mittel zwischen Präzision und Erinnerungswert, das die Wortüberschneidung zwischen vorhergesagten Antworten und Referenzantworten misst
+ `f1_score_quasi`: ähnlich wie f1\$1score, jedoch mit weniger striktem Abgleich, bei dem normalisierter Text verglichen und geringfügige Unterschiede ignoriert werden
+ `bleu`: misst die Genauigkeit von N-Gramm-Übereinstimmungen zwischen generiertem Text und Referenztext, was häufig bei der Bewertung von Übersetzungen verwendet wird.
Geben Sie für `llm_judge` und`mm_llm_judge`, bringen Sie Ihren eigenen Datensatz-Benchmark mit, folgende Kennzahlen zurück:
+ `a_scores`: Anzahl der Siege von `response_A` bei Vorwärts- und Rückwärtsdurchläufen zur Bewertung
+ `a_scores_stderr`: Standardfehler von `response_A_scores` bei paarweisen Beurteilungen
+ `b_scores`: misst die Anzahl der Siege von `response_B` bei Vorwärts- und Rückwärtsdurchläufen zur Bewertung.
+ `a_scores_stderr`: Standardfehler von `response_B_scores` bei paarweisen Beurteilungen
+ `ties`: Anzahl der Beurteilungen, bei denen `response_A` und `response_B` als gleichwertig bewertet wurden
+ `ties_stderr`: Standardfehler von `ties` bei paarweisen Beurteilungen
+ `inference_error`: Anzahl der Beurteilungen, die nicht richtig bewertet werden konnten
+ `score`: Gesamtpunktzahl basierend auf Siegen aus Vorwärts- und Rückwärtsdurchläufen für `response_B`
+ `score_stderr`: Gesamtpunktzahl basierend auf Siegen aus Vorwärts- und Rückwärtsdurchläufen für `response_B`
+ `inference_error_stderr`: Standardfehler der Gesamtpunktzahl bei paarweisen Beurteilungen
+ `winrate`: die Wahrscheinlichkeit, dass `response_B` gegenüber `response_A` vorgezogen wird, berechnet anhand der Bradley-Terry-Wahrscheinlichkeit
+ `lower_rate`: Untergrenze (2,5. Perzentil) der geschätzten Gewinnrate aus dem Bootstrap-Sampling
+ `upper_rate`: Obergrenze (97,5. Perzentil) der geschätzten Gewinnrate aus dem Bootstrap-Sampling
**Konfiguration der Inferenz (optional)**
```
inference:
max_new_tokens: 2048
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`: maximale Anzahl der zu generierenden Token. Muss eine Ganzzahl sein. (Für LLM Judge nicht verfügbar.)
+ `top_k`: Anzahl der zu berücksichtigenden Token mit der höchsten Wahrscheinlichkeit. Muss eine Ganzzahl sein.
+ `top_p`: kumulativer Wahrscheinlichkeitsschwellenwert für das Token-Sampling. Muss ein Gleitkommawert zwischen 1,0 und 0,0 sein.
+ `temperature`: Zufälligkeit bei der Token-Auswahl (höher = eher zufällig). Behalten Sie 0 bei, um ein deterministisches Ergebnis zu erhalten. Typ Float, der Mindestwert ist 0.
+ `top_logprobs`: Die Anzahl der wichtigsten Logprobs, die in der Inferenzantwort zurückgegeben werden sollen. Dieser Wert muss eine Ganzzahl zwischen 0 und 20 sein. Logprobs enthalten die betrachteten Ausgabetokens und die Protokollwahrscheinlichkeiten jedes im Nachrichteninhalt zurückgegebenen Ausgabetokens.
+ `reasoning_effort`: steuert das Argumentationsverhalten für Modelle, die zum Denken fähig sind. Wird `reasoning_effort` nur gesetzt, wenn (derzeit) ein `model_type` Modell angegeben wird, das zu Argumenten fähig ist. `amazon.nova-2-lite-v1:0:256k` Verfügbare Optionen sind Null (Standardwert, falls nicht festgelegt; deaktiviert Argumentation), Niedrig oder Hoch.
### Ausgabeformat „Log-Wahrscheinlichkeit“
Wenn `top_logprobs` es in Ihren Inferenzeinstellungen konfiguriert ist, enthält die Evaluationsausgabe Protokollwahrscheinlichkeiten auf Tokenebene in den Parquet-Dateien. Jede Token-Position enthält ein Wörterbuch der wichtigsten Token-Kandidaten mit ihren Log-Wahrscheinlichkeiten in der folgenden Struktur:
```
{
"Ġint": {"logprob_value": -17.8125, "decoded_value": " int"},
"Ġthe": {"logprob_value": -2.345, "decoded_value": " the"}
}
```
Jeder Token-Eintrag enthält:
+ `logprob_value`: Der Log-Wahrscheinlichkeitswert für das Token
+ `decoded_value`: Die menschenlesbare dekodierte Zeichenkettendarstellung des Tokens
Das rohe Tokenizer-Token wird als Wörterbuchschlüssel verwendet, um die Einzigartigkeit zu gewährleisten und bietet gleichzeitig eine lesbare Interpretation. `decoded_value`
### Beispiele für Bewertungsrezepte
Amazon Nova bietet vier verschiedene Arten von Bewertungsrezepten. [Alle Rezepte sind im SageMaker HyperPod Rezepte-Repository verfügbar. GitHub ](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection)
**Topics**
#### Allgemeine Text-Benchmark-Rezepte
Diese Rezepte ermöglichen es Ihnen, die grundlegenden Funktionen von Amazon-Nova-Modellen anhand einer umfassenden Suite von reinen Text-Benchmarks zu bewerten.
Rezeptformat: `xxx_general_text_benchmark_eval.yaml`.
#### Benchmark-Rezepte mit eigenem Datensatz
Diese Rezepte ermöglichen es Ihnen, Ihren eigenen Datensatz für das Benchmarking zu verwenden und die Modellergebnisse anhand verschiedener Arten von Metriken mit Referenzantworten zu vergleichen.
Rezeptformat: `xxx_ bring_your_own_dataset_eval.yaml`.
**Anforderungen für die Verwendung des eigenen Datensatzes**
Dateiformat:
+ Eine einzige `gen_qa.jsonl`-Datei mit Bewertungsbeispielen. Der Dateiname sollte `gen_qa.jsonl` und kein anderer sein.
+ Sie müssen Ihren Datensatz an einen S3-Standort hochladen, auf den SageMaker KI-Schulungsjobs zugreifen können.
+ Die Datei muss dem erforderlichen Schemaformat für den allgemeinen Q&A-Datensatz entsprechen.
Anforderungen an das Schemaformat — Jede Zeile in der `.jsonl` Datei muss ein JSON-Objekt mit den folgenden Feldern sein.
+ Pflichtfelder
`query`: Zeichenfolge, die die Frage oder Anweisung enthält, für die eine Antwort erforderlich ist
`response`: Zeichenfolge, die die erwartete Modellausgabe enthält
+ Optionale Felder
`system`: Zeichenfolge, die den System-Prompt enthält, der vor der Verarbeitung der Abfrage das Verhalten, die Rolle oder die Persönlichkeit des KI-Modells festlegt
`images`: Array, das eine Liste von Objekten mit Datenattributen enthält (Base64-kodierte Bildzeichenfolgen).
`metadata`: Zeichenfolge, die Metadaten enthält, die dem Eintrag zu Tagging-Zwecken zugeordnet sind.
**Beispieleintrag**
```
{
"system":"You are an 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 who 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 and follow 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"
}{
"system": "Image inference: ",
"query": "What is the number in the image? Please just use one English word to answer.",
"response": "two",
"images": [
{
"data": "data:image/png;Base64,iVBORw0KGgoA ..."
}
]
}
```
Um Ihren benutzerdefinierten Datensatz zu verwenden, ändern Sie Ihr Bewertungsrezept, indem Sie die folgenden Pflichtfelder hinzufügen, ohne die bestehende Konfiguration zu ändern:
```
evaluation:
task: gen_qa
strategy: gen_qa
metric: all
```
**Einschränkungen**
+ Pro Bewertung ist nur eine `.jsonl`-Datei zulässig.
+ Die Datei muss strikt dem definierten Schema folgen.
##### Bringen Sie Ihre eigenen Metriken mit
Sie können Ihre eigenen Metriken verwenden, um Ihren Workflow zur Modellevaluierung mit benutzerdefinierten Funktionen für die Vorverarbeitung, Nachverarbeitung und Metriken vollständig anzupassen. Die Vorverarbeitung ermöglicht es Ihnen, Eingabedaten zu verarbeiten, bevor sie an den Inferenzserver gesendet werden, und die Nachverarbeitung ermöglicht es Ihnen, die Metrikberechnung anzupassen und benutzerdefinierte Metriken an Ihre Bedürfnisse zurückzugeben.
Gehen Sie wie folgt vor, um Ihre eigenen Metriken mit dem benutzerdefinierten Evaluierungs-SDK zu erstellen.
1. Wenn Sie dies noch nicht getan haben, [erstellen Sie in Ihrem AWS-Konto ersten eine AWS Lambda Funktion](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html).
1. Laden Sie die vorgefertigte `nova-custom-eval-layer.zip` Datei aus dem [GitHub Repository](https://github.com/aws/nova-custom-eval-sdk/releases) herunter. Sie können dieses Open-Source-SDK für die benutzerdefinierte Evaluierung von Nova verwenden, um Eingabe- und Ausgabe-Payloads für Ihre benutzerdefinierte Funktion zu validieren und eine einheitliche Oberfläche für die Integration mit Novas Evaluierung von Bring Your Own Metrics während des Trainings bereitzustellen.
1. Laden Sie die benutzerdefinierte Lambda-Ebene mit dem folgenden Befehl hoch:
```
aws lambda publish-layer-version \
--layer-name nova-custom-eval-layer \
--zip-file fileb://nova-custom-eval-layer.zip \
--compatible-runtimes python3.12 python3.11 python3.10 python3.9
```
1. Fügen Sie diese Ebene als benutzerdefinierte Ebene zu Ihrer Lambda-Funktion hinzu, zusammen mit der erforderlichen AWS Ebene: `AWSLambdaPowertoolsPythonV3-python312-arm64` (für die `pydantic` Abhängigkeit erforderlich).
1. Aktualisieren Sie Ihren Lambda-Code anhand des bereitgestellten Beispiels und ändern Sie den Code nach Bedarf. Dieser Beispielcode erstellt eine Lambda-Funktion für die benutzerdefinierte Evaluierung von Nova mit Vor- und Nachverarbeitungsschritten für die Modellevaluierung.
```
from nova_custom_evaluation_sdk.processors.decorators import preprocess, postprocess
from nova_custom_evaluation_sdk.lambda_handler import build_lambda_handler
@preprocess
def preprocessor(event: dict, context) -> dict:
data = event.get('data', {})
return {
"statusCode": 200,
"body": {
"system": data.get("system"),
"prompt": data.get("prompt", ""),
"gold": data.get("gold", "")
}
}
@postprocess
def postprocessor(event: dict, context) -> dict:
# data is already validated and extracted from event
data = event.get('data', [])
inference_output = data.get('inference_output', '')
gold = data.get('gold', '')
metrics = []
inverted_accuracy = 0 if inference_output.lower() == gold.lower() else 1.0
metrics.append({
"metric": "inverted_accuracy_custom",
"value": accuracy
})
# Add more metrics here
return {
"statusCode": 200,
"body": metrics
}
# Build Lambda handler
lambda_handler = build_lambda_handler(
preprocessor=preprocessor,
postprocessor=postprocessor
)
```
1. Gewähren Sie Lambda Zugriff auf den Evaluierungsjob. Stellen Sie sicher, dass die für den Evaluierungsjob angegebene Ausführungsrolle eine Richtlinie enthält, die Ihre Lambda-Funktion aufruft. Hier ist eine Beispielrichtlinie.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "LambdaAccess",
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"StringLike": {
"aws:PrincipalArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-ARN"
}
}
},
{
"Sid": "DenyNonAWSEventSourcesForLambda",
"Effect": "Deny",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:111122223333:function:ExampleFunction",
"Condition": {
"Null": {
"lambda:EventSourceToken": false
}
}
}
]
}
```
------
1. Überprüfen Sie das Lambda-Payload-Schema. In der folgenden Tabelle ist das Lambda-Anforderungs- und Antwortschema aufgeführt. Sie können Ihr Schema mit dem benutzerdefinierten Evaluierungs-SDK von Nova validieren.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/nova/latest/nova2-userguide/nova-model-evaluation.html)
1. Ändern Sie die Rezeptdatei. Ein Beispiel.
```
processor:
lambda_arn: arn:aws:lambda:us-east-1:111122223333:function:name
lambda_type: "custom_metrics"
preprocessing:
enabled: true
postprocessing:
enabled: true
aggregation: average
```
+ `lambda-arn`: Der Amazon-Ressourcenname (ARN) für Ihre Lambda-Funktion, die die Vor- und Nachverarbeitung übernimmt.
+ `lambda_type`: „custom\$1metrics“ oder „rft“.
+ `preprocessing`: Ob benutzerdefinierte Vorverarbeitungsvorgänge aktiviert werden sollen.
+ `postprocessing`: Ob benutzerdefinierte Nachverarbeitungsvorgänge aktiviert werden sollen.
+ `aggregation`: Integrierte Aggregationsfunktion (gültige Optionen: min, max, average, sum).
**Einschränkungen**
+ Bring Your Own Metrics gilt nur für Texteingabe-Datensätze.
+ Multimodale Eingabedatensätze werden nicht unterstützt.
+ Der Vorverarbeitungsschritt verarbeitet das Metadatenfeld nicht.
#### Benchmark-Rezepte für Nova LLM-as-a-Judge
Nova LLM Judge ist eine Modellbewertungsfunktion, mit der Sie die Qualität der Antworten eines Modells mit den Antworten eines Basismodells anhand eines benutzerdefinierten Datensatzes vergleichen können. Sie akzeptiert einen Datensatz, der Prompts, Basisantworten und Herausforderungsantworten enthält, und stellt anhand eines Nova-Judge-Modells eine auf der [Bradley-Terry](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model)-Wahrscheinlichkeit basierende Gewinnratenmetrik mit paarweisen Vergleichen bereit. Rezeptformat: `xxx_llm_judge_eval.yaml`.
**Anforderungen an den Nova-LLM-Datensatz**
Dateiformat:
+ Eine einzige `llm_judge.jsonl`-Datei mit Bewertungsbeispielen. Der Dateiname sollte `llm_judge.jsonl` und kein anderer sein.
+ Sie müssen Ihren Datensatz an einen S3-Standort hochladen, auf den SageMaker KI-Schulungsjobs zugreifen können.
+ Die Datei muss dem für den `llm_judge`-Datensatz erforderlichen Schemaformat entsprechen.
+ Der Eingabedatensatz sollte sicherstellen, dass alle Datensätze eine Kontextlänge von weniger als 12 000 haben.
Schemaformat – Jede Zeile in der `.jsonl`-Datei muss ein JSON-Objekt mit den folgenden Feldern sein.
+ Pflichtfelder
`prompt`: Zeichenfolge, die den Prompt für die generierte Antwort enthält
`response_A`: Zeichenfolge, die die Basisantwort enthält
`response_B`: Zeichenfolge, die die alternative Antwort enthält, die mit der Basisantwort verglichen wird
Beispieleintrag
```
{
"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."
}
```
Um Ihren benutzerdefinierten Datensatz zu verwenden, ändern Sie Ihr Bewertungsrezept mit den folgenden Pflichtfeldern, verändern Sie jedoch nicht den Inhalt:
```
evaluation:
task: llm_judge
strategy: judge
metric: all
```
**Einschränkungen**
+ Pro Bewertung ist nur eine `.jsonl`-Datei zulässig.
+ Die Datei muss strikt dem definierten Schema folgen.
+ Die Nova-Judge-Modelle sind für die Spezifikationen von Micro, Lite und Pro identisch.
+ Benutzerdefinierte Judge-Modelle werden derzeit nicht unterstützt.
##### Nova LLM als Jurorin für multimodale (Bild-) Benchmark-Rezepte
Nova LLM Judge for multi-modal (Bild), kurz für Nova MM\$1LLM Judge, ist eine Modellbewertungsfunktion, mit der Sie die Qualität der Antworten eines Modells anhand eines benutzerdefinierten Datensatzes mit den Antworten eines Basismodells vergleichen können. Es akzeptiert einen Datensatz, der Eingabeaufforderungen, Basisantworten und Challenger-Antworten sowie Bilder in Form einer Base64-kodierten Zeichenfolge enthält, und verwendet dann ein Nova Judge-Modell, um durch paarweise Vergleiche eine Gewinnratenmetrik bereitzustellen, die auf der [Bradley-Terry-Wahrscheinlichkeit](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) basiert. Rezeptformat: `xxx_mm_llm_judge_eval.yaml`.
**Anforderungen an den Nova-LLM-Datensatz**
Dateiformat:
+ Eine einzige `mm_llm_judge.jsonl`-Datei mit Bewertungsbeispielen. Der Dateiname muss exakt sein. `llm_judge.jsonl`
+ Sie müssen Ihren Datensatz an einen S3-Standort hochladen, an dem SageMaker KI-Schulungsjobs darauf zugreifen können.
+ Die Datei muss dem für den `mm_llm_judge`-Datensatz erforderlichen Schemaformat entsprechen.
+ Der Eingabedatensatz sollte sicherstellen, dass alle Datensätze eine Kontextlänge von weniger als 12 k haben, mit Ausnahme des Bildattributs.
Schemaformat – Jede Zeile in der `.jsonl`-Datei muss ein JSON-Objekt mit den folgenden Feldern sein.
+ Pflichtfelder
`prompt`: Zeichenfolge, die den Prompt für die generierte Antwort enthält
`images`: Array, das eine Liste von Objekten mit Datenattributen enthält (Werte sind Base64-kodierte Bildzeichenfolgen).
`response_A`: Zeichenfolge, die die Basisantwort enthält
`response_B`: Zeichenfolge, die die alternative Antwort enthält, die mit der Basisantwort verglichen wird
Beispieleintrag
Aus Gründen der besseren Lesbarkeit enthält das folgende Beispiel neue Zeilen und Einrückungen, aber im eigentlichen Datensatz sollte sich jeder Datensatz in einer einzigen Zeile befinden.
```
{
"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 are in each 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"
}
```
Um Ihren benutzerdefinierten Datensatz zu verwenden, ändern Sie Ihr Bewertungsrezept mit den folgenden Pflichtfeldern, verändern Sie jedoch nicht den Inhalt:
```
evaluation:
task: mm_llm_judge
strategy: judge
metric: all
```
**Einschränkungen**
+ Pro Bewertung ist nur eine `.jsonl`-Datei zulässig.
+ Die Datei muss strikt dem definierten Schema folgen.
+ Nova MM Judge-Modelle unterstützen nur Bildreferenzen.
+ Die Nova MM Judge-Modelle sind in allen Spezifikationen von Amazon Nova Micro, Amazon Nova Lite und Amazon Nova Pro identisch.
+ Benutzerdefinierte Judge-Modelle werden derzeit nicht unterstützt.
+ Der Amazon S3 S3-Image-URI wird nicht unterstützt.
+ Der Eingabedatensatz sollte sicherstellen, dass alle Datensätze eine Kontextlänge von weniger als 12 k haben, mit Ausnahme des Bildattributs.
#### Evaluierung von CPT-Checkpoints (Continuous Pre-Training)
Die Evaluierung anhand von CPT-Modellen (Continuous Pre-Trained) kann schwieriger sein als bei Modellen, die einer SFT (überwachte Feinabstimmung) unterzogen wurden, da CPT-Modelle regelmäßig nicht in der Lage sind, Anweisungen zu befolgen. Anstatt Anweisungen zu befolgen, fungiert das CPT-Modell als Abschlussmodell, d. h. es wird lediglich versucht, das in der Eingabe-Token-Sequenz enthaltene Muster fortzusetzen. Angesichts dieser Einschränkung funktionieren typische Bewertungsdatensätze aufgrund des „Q&A“ -Formats der Eingaben möglicherweise nicht richtig. Anstatt die Frage zu beantworten, versucht das Modell einfach, dieselbe Frage weiterzuverfolgen. Wenn wir die Datensätze jedoch auf eine bestimmte Art formatieren, sodass die Modelle in einem Abschlussstil angezeigt werden, können wir uns ein Bild von der Leistung des Modells machen.
Folgen Sie den folgenden Schritten, um zu verstehen, wie Sie mithilfe des Nova Forge-Evaluierungsworkflows eine Evaluierung an einem kontinuierlichen, vortrainierten Modell durchführen können.
##### Vorbereitung und Formatierung von Datensätzen
Bei der Bewertung eines CPT-Modells wird der bereits bestehende [Bring Your Own Dataset-Workflow](#nova-model-evaluation-config-byo) genutzt, der bereits im Rahmen der Modellevaluierung von Nova Forge zur Verfügung gestellt wurde. Abfragen innerhalb des Datensatzes müssen jedoch in einem reinen Abschlussformat formatiert werden, da CPT-Modelle nicht auf die gleiche Weise auf Standardaufforderungen im Fragestil reagieren, wie dies bei einem SFT-Modell der Fall wäre.
Eine weitere wichtige häufige Einschränkung von Modellen, die ausschließlich einer CPT unterzogen wurden, ist ihre Unfähigkeit, STOP- oder End-of-Sequenz-Token zu generieren — das bedeutet, dass das Modell weiterhin Tokens generiert, bis es gewaltsam gestoppt wird (z. B. mit dem Parameter max\$1new\$1tokens). Angesichts dieser Einschränkung empfiehlt es sich, die Modelle anhand von Einzel-Token-Antworten (z. B. Multiple-Choice) zu bewerten, um sicherzustellen, dass das Modell nicht weiterhin Junk-Ausgaben generiert, die nach der Aufforderung nicht benötigt werden.
Beispielsweise könnte ein typischer Bewertungsdatensatz (wie MMLU, GPQA, MATH usw.) das Modell mit einer Frage wie der folgenden veranlassen:
```
Early settlements and high population density along coastlines and rivers are
best attributed to which of the following?
A: "Poor climate conditions"
B: "Limited forest cover"
C: "Cars"
D: "Access to trade routes"
(Expected answer is D.)
```
Ein CPT-Modell würde jedoch nicht verstehen, wie diese Frage richtig zu beantworten ist, da es keine Feinabstimmung bei der Befolgung von Anweisungen gibt. Aus diesem Grund müssen CPT-Modelle in einem Abschlussstil abgefragt werden, wie zum Beispiel:
```
Early settlements and high population density along coastlines and rivers
are best attributed to which of the following?
A: Poor climate conditions
B: Limited forest cover
C: Cars
D: Access to trade routes
The correct answer to this question is option
(Expected answer is D.)
```
Nach der Prüfung der Inferenz geben die vom Modell generierten Output-Logprobs Auskunft darüber, ob das Modell die Eingabe korrekt verarbeitet und die richtige Antwort generiert hat. Es kann nicht garantiert werden, dass das Modell immer genau die erwartete Antwort (in diesem Fall den Buchstaben D) liefert. Wenn das Modell korrekt funktioniert, sollte sie jedoch in den Logprobs vorhanden sein.
Ein weiteres Beispiel für eine Eingabeaufforderung ohne Multiple-Choice-Vervollständigung
```
The capital of France is
(Expected answer of Paris)
```
Wir würden erwarten, dass das Modell entweder die Antwort „Paris“ ausgibt oder dass das Token, das „Paris“ entspricht, irgendwo in der Logprobs-Ausgabe erscheint.
##### Formatierung von Datensätzen
Die CPT-Evaluierung nutzt den bestehenden [Bring Your Own Dataset-Workflow](#nova-model-evaluation-config-byo). Die Daten müssen im Format „Query-Response“ in einer JSONL-Datei formatiert werden, die durch neue Zeilen getrennt ist.
Ein Beispiel für einen Datensatz mit 4 Einträgen darin:
```
{"query": "The capital of France is", "response": "Paris"}
{"query": "2 + 2 =", "response": "4"}
{"query": "The mitochondria is the powerhouse of the", "response": "cell"}
{"query": "What is the largest planet?\nA: Mars\nB: Jupiter\nC: Saturn\nD: Earth\nAnswer:", "response": "B"}
```
Jede Zeile muss enthalten:
+ `query`: Der Text der Eingabeaufforderung zur Fertigstellung
+ `response`: Die erwartete Fertigstellung (Ground Truth)
Das Modell erhält Rohtexteingaben ohne Chat-Formatierung. CPT-Modelle sind in der Regel noch nicht mit speziellen Tokens trainiert und reagieren nicht richtig auf Chat-Vorlagen. Wenn Sie also das Modell dazu auffordern, wird NUR die in der Abfrage angegebene Zeichenfolge an das Modell gesendet (mit einem zusätzlichen `[BOS]` Token, dem automatisch ein zusätzliches Token vorangestellt wird).
##### Konfiguration des Rezepts
Hier ist ein Beispiel für ein Rezept, das für die Evaluierung eines CPT-Modells konfiguriert ist:
```
run:
name: cpt_eval_job
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: s3://bucket/path/to/cpt-checkpoint/
evaluation:
task: gen_qa # Required for CPT - bring your own dataset
strategy: gen_qa
metric: all # Returns rouge1, rouge2, rougeL, exact_match, f1_score, bleu
inference:
checkpoint_is_instruction_tuned: "false" # Required for CPT checkpoints
top_logprobs: 5 # Change to desired amount of logprobs to calculate
max_new_tokens: 1 # Keep low for completion tasks
temperature: 0.0
```
Die wichtigsten Änderungen bei der CPT-Bewertung:
+ `checkpoint_is_instruction_tuned: "false"`
Dies ist ein neuer Parameter, der speziell zur Unterstützung von Testläufen an CPT-Checkpoints hinzugefügt wurde. Wenn checkpoint\$1is\$1instruction\$1tuned auf false gesetzt wird, wird die standardmäßige Amazon Nova-Chat-Vorlage **deaktiviert, die normalerweise** die Eingabeaufforderung umschließt.
+ `top_logprobs: 5`
Log-Wahrscheinlichkeiten (logprobs) geben Aufschluss über die Vertrauensverteilung des Modells über die möglichen nächsten Tokens. So können Sie beurteilen, ob das Modell vor dem Training die erwarteten Ergebnisse erzielt hat. Wenn das Modell wie beabsichtigt funktioniert, sollten wir die erwartete Antwort (d. h. „A“, „B“ usw.) in der Regel entweder als generiertes Ausgabetoken oder als Token in den Logprobs betrachten.
+ `max_new_tokens: 1`
CPT-Modelle wurden in der Regel noch nicht darauf trainiert, spezielle „Stop“ - oder „End of Sequence“ -Token zu generieren, um zu signalisieren, wann die Inferenz beendet werden muss. Das bedeutet, dass das Modell in der Regel weiterhin neue Token generiert, bis die spezifische maximale Token-Länge erreicht ist, was zu unnötigen Rückschlüssen führt. In der Regel ist es am effizientesten, die max\$1new\$1tokens auf 1 zu beschränken und eine Eingabeaufforderung bereitzustellen, mit der das Modell anhand einer einzigen Antwort bewertet werden kann (wie bei einer Multiple-Choice-Frage). Wenn Sie max\$1new\$1tokens auf 1 setzen, wird sichergestellt, dass keine zusätzlichen Junk-Token generiert werden.
##### Hauptparameter
+ **checkpoint\$1is\$1instruction\$1tuned**: Muss auf (oder als boolescher Wert) gesetzt werden, um Chat-Vorlagen zu deaktivieren `"false"` `false`
+ **top\$1logprobs**: 5, wird empfohlen, um zu sehen, wie das Modell während der CPT lernt
+ **Aufgabe**: Muss sein `gen_qa` — CPT-Modelle können keine Benchmarks verwenden, bei denen Anweisungen befolgt werden, wie MMLU oder MATH
+ **Strategie**: Muss sein `gen_qa`
+ **max\$1new\$1tokens**: Es wird empfohlen, den Wert niedrig zu halten (1-5), da CPT-Modelle die Fertigstellung und nicht die Generierung durchführen
## Ausführen von Bewertungs-Trainingsjobs
Starten Sie einen Trainingsjob mit dem folgenden Beispielnotizbuch. Bitte sehen Sie sich das folgende Notizbuch als Beispiel für die Ausführung des Evaluierungs-Trainingsjobs an. Weitere Informationen finden Sie unter [Verwenden eines SageMaker KI-Schätzers zur Durchführung eines Trainingsjobs](https://docs.aws.amazon.com//sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry-estimator.html).
### Referenztabellen
Bevor Sie das Notebook ausführen, berücksichtigen Sie bei der Auswahl von Image-URI- und Instance-Konfigurationen die folgenden Referenztabellen.
**Auswahl des Image-URI**
| Rezept | Image-URI |
| --- | --- |
| Bewertungs-Image-URI | 708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest |
**Auswahl des Instance-Typs und der Anzahl von Instances**
| Modell | Job type | Instance-Typ | Empfohlene Anzahl von Instances | Erlaubte Anzahl von Instances |
| --- | --- | --- | --- | --- |
| Amazon Nova Micro | Bewertung (SFT/DPO) | g5.12xlarge | 1 | 1 — 16 |
| Amazon Nova Lite | Bewertung (SFT/DPO) | g5.12xlarge | 1 | 1 — 16 |
| Amazon Nova Pro | Bewertung (SFT/DPO) | p5.48xlarge | 1 | 1 — 16 |
### Beispiel-Notebook
Das folgende Beispiel-Notebook zeigt, wie ein Bewertungs-Trainingsjob ausgeführt wird.
```
# install python SDK
# Do not use sagemaker v3, as sagemaker v3 introduced breaking changes
!pip install sagemaker==2.254.1
import os
import sagemaker,boto3
from sagemaker.inputs import TrainingInput
from sagemaker.pytorch import PyTorch
sagemaker_session = sagemaker.Session()
role = sagemaker.get_execution_role()
# Download recipe from https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/evaluation/nova to local
# Assume the file name be `recipe.yaml`
# Populate parameters
# input_s3_uri = "s3:///input/" # (Optional) Only used for multi-modal dataset or bring your own dataset s3 location
output_s3_uri= "s3:///output/" # Output data s3 location, a zip containing metrics json and tensorboard metrics files will be stored to this location
instance_type = "instance_type" # ml.g5.16xlarge as example
instance_count = 1 # The number of instances for inference (set instance_count > 1 for multi-node inference to accelerate evaluation)
job_name = "your job name"
recipe_path = "recipe path" # ./recipe.yaml as example
image_uri = "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-TJ-Eval-V2-latest" # Do not change
output_kms_key = "" # optional, leave blank for Amazon managed encryption
# (Optional) To bring your own dataset and LLM judge for evaluation
# evalInput = TrainingInput(
# s3_data=input_s3_uri,
# distribution='FullyReplicated',
# s3_data_type='S3Prefix'
#)
estimator = PyTorch(
output_path=output_s3_uri,
base_job_name=job_name,
role=role,
instance_type=instance_type,
instance_count=instance_count,
training_recipe=recipe_path,
sagemaker_session=sagemaker_session,
image_uri=image_uri,
output_kms_key=output_kms_key
)
estimator.fit()
# If input dataset exist, pass in inputs
# estimator.fit(inputs={"train": evalInput})
```
## Auswertung und Analyse der Bewertungsergebnisse
Nach erfolgreichem Abschluss Ihres Bewertungsjobs können Sie die Ergebnisse anhand der folgenden Schritte bewerten und analysieren.
**Gehen Sie wie folgt vor, um die Ergebnisse zu bewerten und zu analysieren.**
1. Machen Sie sich mit der Struktur des Ausgabespeicherorts vertraut. Die Ergebnisse werden an Ihrem angegebenen Amazon-S3-Ausgabespeicherort als komprimierte Datei gespeichert:
```
s3://your-bucket/output/benchmark-name/
└── job_name/
└── output/
└── output.tar.gz
```
1. Laden Sie die `output.tar.gz`-Datei aus Ihrem Bucket herunter. Extrahieren Sie den Inhalt.
```
run_name/
├── eval_results/
| └── results_[timestamp].json
│ └── inference_output.jsonl (only present for gen_qa)
| └── details/
| └── model/
| └── /
| └──details__#_.parquet
└── tensorboard_results/
└── eval/
└── events.out.tfevents.[timestamp]
```
+ `results_[timestamp].json` – JSON-Datei mit den Ausgabemetriken
+ `details__#_.parquet` – Inferenz-Ausgabedatei (außer `strong_reject`)
+ `events.out.tfevents.[timestamp]`- TensorBoard Ausgabedatei
+ `inference_output.jsonl` – Bereinigte Inferenzausgabedatei (nur für `gen_qa`-Aufgaben)
1. Ergebnisse anzeigen in TensorBoard. So visualisieren Sie Ihre Bewertungsmetriken:
1. Laden Sie den extrahierten Ordner in einen S3-Bucket hoch.
1. Navigieren Sie zu SageMaker KI TensorBoard
1. Wählen Sie Ihre „S3-Ordner“.
1. Fügen Sie den S3-Ordnerpfad hinzu.
1. Warten Sie, bis die Synchronisation abgeschlossen ist.
1. Analysieren Sie die Inferenzausgaben. Alle Bewertungsaufgaben, mit Ausnahme von `llm_judge` und `strong_reject`, enthalten die folgenden Felder für die Analyse in der Inferenzausgabe.
+ `full_prompt`- Die vollständige Benutzeraufforderung, die an das für die Bewertungsaufgabe verwendete Modell gesendet wird.
+ `gold`- Das Feld, das die richtige (n) Antwort (en) enthält, wie im Datensatz angegeben.
+ `metrics`- Das Feld, das die anhand der einzelnen Inferenz bewerteten Metriken enthält. Werte, die aggregiert werden müssen, haben keinen Wert in den einzelnen Inferenzausgaben.
+ `predictions`- Das Feld, das eine Liste der Modellausgaben für die angegebene Eingabeaufforderung enthält.
+ `pred_logits`- Das Feld, das die betrachteten Ausgabetokens und die Log-Wahrscheinlichkeiten jedes im Nachrichteninhalt zurückgegebenen Ausgabetokens enthält.
Anhand dieser Felder können Sie die Ursache für metrische Unterschiede ermitteln und das Verhalten der benutzerdefinierten Modelle verstehen.
Für `llm_judge` enthält die Inferenzausgabedatei die folgenden Felder unter dem Metrikfeld pro Bewertungspaar.
+ `forward_output` – die reinen Präferenzen des Judge bei der Bewertung der Reihenfolge nach (response\$1A, response\$1B)
+ `backward_output` – die reinen Präferenzen des Judge bei der Bewertung in umgekehrter Reihenfolge (response\$1B, response\$1A)
+ `Pairwise metrics` – Metriken, die paarweise für Vorwärts- und Rückwärtsbeurteilungen berechnet werden, darunter `a_scores`, `b_scores`, `ties`, `inference-score` und `score`.
**Anmerkung**
Aggregierte Metriken wie `winrate` sind nur in den zusammenfassenden Ergebnisdateien verfügbar, nicht nach individueller Beurteilung.
Für `gen_qa` enthält die Datei `inference_output.jsonl` die folgenden Felder für jedes JSON-Objekt:
+ Prompt – der letzte Prompt, der an das Modell gesendet wurde
+ Inferenz – die unformatierte Inferenzausgabe des Modells
+ gold — Die Zielantwort aus dem Eingabedatensatz
+ metadata — Die Metadatenzeichenfolge aus dem Eingabedatensatz, falls angegeben
## Bewährte Methoden zur Bewertung und Problembehebung
### Best Practices
Im Folgenden sind einige bewährte Verfahren für den Bewertungsprozess aufgeführt.
+ Organisieren Sie Ihre Ausgabepfade nach Modell und Benchmark-Typ.
+ Halten Sie konsistente Namenskonventionen ein, um die Nachverfolgung zu vereinfachen.
+ Speichern Sie die extrahierten Ergebnisse an einem sicheren Ort.
+ Überwachen Sie den TensorBoard Synchronisierungsstatus, um sicherzustellen, dass Daten erfolgreich geladen wurden.
### Fehlerbehebung
Sie können die CloudWatch Protokollgruppe `/aws/sagemaker/TrainingJobs` zum Trainieren von Job-Fehlerprotokollen verwenden.
#### Ausfall des Motorkerns
**Problem:**
Wenn Sie Folgendes sehen:
```
RuntimeError: Engine core initialization failed.
```
**Ursache:**
Obwohl dies ein allgemeiner Fehler ist, der mehrere Ursachen haben kann, tritt er in der Regel auf, wenn zwischen dem Modell-Checkpoint, den Sie laden möchten, und dem angegebenen Modelltyp eine Diskrepanz besteht. Sie möchten z. B. einen fein abgestimmten Nova 2.0 Lite-Modellprüfpunkt testen, aber der von Ihnen angegebene Modelltyp ist der Modelltyp 1.0. z.B. `amazon.nova-micro-v1:0:128k`
Das richtige Mapping sollte sein
```
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod # or s3://escrow_bucket/model_location
```
**Vorbeugung:**
Vergewissern Sie sich, `model_name_or_path` dass das auf der rechten Seite abgebildet ist, `model_type` bevor Sie den Bewertungsjob abschicken.
## Verfügbare Unteraufgaben
Im Folgenden sind die verfügbaren Unteraufgaben für die Modellevaluierung in verschiedenen Bereichen aufgeführt, darunter MMLU (Massive Multitask Language Understanding), BBH (Big Bench Hard), MATH und MMMU (Massive Multidiscipline Multimodal Understanding). Diese Unteraufgaben ermöglichen es Ihnen, die Leistung Ihres Modells in Bezug auf bestimmte Fähigkeiten und Wissensbereiche zu bewerten.
**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 (Mathematik)**
```
MATH_SUBTASKS = [
"algebra",
"counting_and_probability",
"geometry",
"intermediate_algebra",
"number_theory",
"prealgebra",
"precalculus",
```
**MMMU**
```
MATH_SUBTASKS = [
"Accounting",
"Agriculture",
"Architecture_and_Engineering",
"Art",
"Art_Theory",
"Basic_Medical_Science",
"Biology",
"Chemistry",
"Clinical_Medicine",
"Computer_Science",
"Design",
"Diagnostics_and_Laboratory_Medicine",
"Economics",
"Electronics",
"Energy_and_Power",
"Finance",
"Geography",
"History",
"Literature",
"Manage",
"Marketing",
"Materials",
"Math",
"Mechanical_Engineering",
"Music",
"Pharmacy",
"Physics",
"Psychology",
"Public_Health",
"Sociology",
```
Evaluieren Sie Ihre maßgeschneiderten Nova-Modelle mithilfe verschiedener Bewertungsmethoden und Metriken.
**Topics**
+ [Voraussetzungen](#nova-model-evaluation-prerequisites)
+ [Verfügbare Benchmark-Aufgaben](#nova-model-evaluation-benchmark)
+ [Bewertung spezifischer Konfigurationen](#nova-model-evaluation-config)
+ [Ausführen von Bewertungs-Trainingsjobs](#nova-model-evaluation-notebook)
+ [Auswertung und Analyse der Bewertungsergebnisse](#nova-model-evaluation-assess)
+ [Bewährte Methoden zur Bewertung und Problembehebung](#nova-model-evaluation-best-practices)
+ [Verfügbare Unteraufgaben](#nova-model-evaluation-subtasks)
+ [Bewertung des Argumentationsmodells](nova-reasoning-model-evaluation.md)
+ [RFT-Evaluierung](nova-rft-evaluation.md)
+ [Implementierung von Belohnungsfunktionen](nova-implementing-reward-functions.md)
# Bewertung des Argumentationsmodells
## -Übersicht
Die Unterstützung von Argumentationsmodellen ermöglicht die Evaluierung mit Hilfe von Nova-Modellen, die eine explizite interne Argumentation durchführen, bevor endgültige Antworten generiert werden. Diese Funktion nutzt die Steuerung auf API-Ebene über den `reasoning_effort` Parameter, um die Argumentationsfunktion dynamisch zu aktivieren oder zu deaktivieren, wodurch möglicherweise die Antwortqualität bei komplexen Analyseaufgaben verbessert wird.
**Unterstützte Modelle**
+ amazon.nova-2-lite-v 1:0:256 k
## Konfiguration des Rezepts
Ermöglichen Sie die Argumentation, indem Sie den `reasoning_effort` Parameter zum `inference` Abschnitt Ihres Rezepts hinzufügen:
```
run:
name: reasoning-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 HyperPod job
output_s3_path: "" # [MODIFIABLE] Output path for SageMaker HyperPod job (not compatible with SageMaker Training jobs)
evaluation:
task: mmlu # [MODIFIABLE] Evaluation task
strategy: zs_cot # [MODIFIABLE] Evaluation strategy
metric: accuracy # [MODIFIABLE] Metric calculation method
inference:
reasoning_effort: high # [MODIFIABLE] Enables reasoning mode; options: low/high or null to disable
max_new_tokens: 32768 # [MODIFIABLE] Maximum tokens to generate, recommended value when reasoning_effort set to high
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
```
## Verwenden Sie den Parameter reasoning\$1effort
Der `reasoning_effort` Parameter steuert das Argumentationsverhalten für Modelle, die zur Argumentation fähig sind.
### Voraussetzungen
+ **Modellkompatibilität** — `reasoning_effort` Nur festgelegt, wenn (derzeit) ein Modell `model_type` angegeben wird, das zu Argumenten fähig ist `amazon.nova-2-lite-v1:0:256k`
+ **Fehlerbehandlung** — Die Verwendung `reasoning_effort` mit nicht unterstützten Modellen schlägt fehl mit `ConfigValidationError: "Reasoning mode is enabled but model '{model_type}' does not support reasoning. Please use a reasoning-capable model or disable reasoning mode."`
### Verfügbare Optionen
| Option | Behavior | Token-Limit | Anwendungsfall |
| --- | --- | --- | --- |
| null (Standard) | Deaktiviert den Argumentationsmodus | – | Standardauswertung ohne Mehraufwand bei der Argumentation |
| low | Ermöglicht Argumentation mit Einschränkungen | 4.000 Tokens für internes Denken | Szenarien, die eine präzise Argumentation erfordern; optimiert im Hinblick auf Geschwindigkeit und Kosten |
| high | Ermöglicht Argumentation ohne Einschränkungen | Keine Tokenbegrenzung für internes Denken | Komplexe Probleme, die umfangreiche Analysen und step-by-step Überlegungen erfordern |
| Trainingsmethode | Verfügbare Optionen | Wie konfiguriert man |
| --- | --- | --- |
| SFT (überwachte Feinabstimmung) | Nur hoch oder Aus | Verwenden Sie reasoning\$1enabled: true (hoch) oder reasoning\$1enabled: false (off) |
| RFT (Feinabstimmung von Verstärkungen) | Niedrig, Hoch oder Aus | Verwenden Sie reasoning\$1effort: low oder reasoning\$1effort: high. Lassen Sie das zu deaktivierende Feld weg. |
| Bewertung | Niedrig, Hoch oder Aus | Verwenden Sie reasoning\$1effort: low oder reasoning\$1effort: high. Verwenden Sie null, um zu deaktivieren. |
### Wann sollte das Argumentieren aktiviert werden
**Verwenden Sie den Argumentationsmodus (`low`oder`high`) für**
+ Komplexe Problemlösungsaufgaben (Mathematik, Logikrätsel, Programmieren)
+ Mehrstufige analytische Fragen, die eine gründliche Argumentation erfordern
+ Aufgaben, bei denen detaillierte Erklärungen oder step-by-step Überlegungen die Genauigkeit verbessern
+ Szenarien, in denen die Qualität der Antworten Vorrang vor der Geschwindigkeit hat
**Verwenden Sie den Modus ohne Argumentation (`null`oder lassen Sie den Parameter weg) für**
+ Einfache Fragen und Antworten oder sachliche Fragen
+ Kreative Schreibaufgaben
+ Wenn schnellere Reaktionszeiten entscheidend sind
+ Leistungsbenchmarking, bei dem der Argumentationsaufwand ausgeschlossen werden sollte
+ Kostenoptimierung, wenn Argumentation die Aufgabenleistung nicht verbessert
### Fehlerbehebung
**Fehler: „Der Argumentationsmodus ist aktiviert, aber das Modell unterstützt kein Argumentieren“**
**Ursache**: Der `reasoning_effort` Parameter ist auf einen Wert ungleich Null gesetzt, aber der angegebene Wert unterstützt `model_type` keine Argumentation.
**Auflösung**
+ Stellen Sie sicher, dass Ihr Modelltyp `amazon.nova-2-lite-v1:0:256k`
+ Wenn Sie ein anderes Modell verwenden, wechseln Sie entweder zu einem Modell, das vernünftiges Denken ermöglicht, oder entfernen Sie den `reasoning_effort` Parameter aus Ihrem Rezept
# RFT-Evaluierung
## Was ist eine 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 die RFT-Evaluierung 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.
## 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`
+ `reference_answer`— Erwartete Leistung oder Ground-Truth-Daten, die von Ihrer Belohnungsfunktion für die Bewertung verwendet werden
### Beispiel für ein Datenformat
```
{
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Solve for x. Return only JSON like {\"x\": }. Equation: 2x + 5 = 13"
}
]
}
],
"reference_answer": {
"x": 4
}
}
```
### Aktuelle Einschränkungen
+ 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-Notebook
Ein vollständiges Beispiel finden Sie unter [Test-Notizbücher](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook).
### Beispiel für eine Rezeptkonfiguration
```
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 and use TrainingInput in sagemaker python SDK
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: 8192 # [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 # [MODIFIABLE] Set between 1-20 to enable logprobs output
# =============================================================================
# Bring Your Own Reinforcement Learning Environment
# =============================================================================
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
1. Laden Sie die Lambda-Schicht aus den [nova-custom-eval-sdk Versionen](https://github.com/aws/nova-custom-eval-sdk/releases) herunter.
1. Veröffentlichen Sie die Lambda-Ebene mit der AWS Befehlszeilenschnittstelle (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 Management Console hinzu (Wählen Sie die benutzerdefinierte Ebene preset-function-layer 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\$1code-Funktion
Evaluiert Aufgaben zur Python-Codegenerierung, indem Code anhand von Testfällen ausgeführt und die Richtigkeit gemessen wird.
**Beispiel für ein Eingabedatensatzformat**
```
{"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"]}}
```
**Schlüssel-Features**
+ 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\$1math-Funktion
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"}
```
**Schlüssel-Features**
+ Symbolische mathematische Bewertung mit SymPy
+ Mehrere Antwortformate (LaTeX, Klartext, symbolisch)
+ Mathematische Äquivalenzprüfung
+ Normalisierung und Vereinfachung von Ausdrücken
### Datenformatanforderungen
**Zur Codeauswertung**
+ Eingaben: Array von Funktionsargumenten (richtige Typen: Ganzzahlen, Zeichenketten usw.)
+ Ausgaben: Array erwarteter Rückgabewerte (richtige Typen: Boolesche Werte, Zahlen usw.)
+ Code: Muss in Python mit klaren Funktionsdefinitionen sein
**Für die mathematische Auswertung**
+ Referenzantwort: Mathematischer Ausdruck oder numerischer Wert
+ Antwort: Kann LaTe X, Klartext oder symbolische Notation sein
+ Äquivalenz: Wird symbolisch überprüft, nicht nur beim Abgleich von Zeichenketten
### Best Practices
+ Verwenden Sie in Testfällen die richtigen Datentypen (Ganzzahlen im Vergleich zu Zeichenketten, boolesche Werte im Vergleich zu „True“)
+ Sorgen Sie bei Codeproblemen für klare Funktionssignaturen
+ 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
### Fehlerbehandlung
Beide Funktionen beinhalten eine robuste Fehlerbehandlung für:
+ Kompilierungsfehler im generierten Code
+ Laufzeitausnahmen während der Ausführung
+ Fehlerhaft formatierte Eingabedaten
+ Timeout-Szenarien für Endlosschleifen
+ Ungültige mathematische Ausdrücke
## Erstellen Sie Ihre Belohnungsfunktion
### Lambda-ARN-Anforderungen
Ihr Lambda-ARN muss diesem Format folgen:
```
"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)
```
### 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..."
}
]
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
]
```
**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`— Reihe von Einzelmetriken 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 Ausführungsrolle muss über Berechtigungen zum Aufrufen Ihrer Lambda-Funktion verfügen. Fügen Sie diese Richtlinie zu Ihrer SageMaker 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:*:*:*"
}
]
}
```
Wenn Ihre Lambda-Funktion auf andere AWS Dienste zugreift (z. B. 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 und laden Sie Ihre JSONL-Datei auf S3 hoch: `s3://your-bucket/eval-data/eval_data.jsonl`
1. **Konfigurieren Sie Ihr 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. **Evaluierung ausführen** — Führen Sie den Evaluierungsjob mit dem mitgelieferten Notizbuch aus: [Evaluierungs-Notebooks](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook)
1. **Fortschritt überwachen** — Überwachen Sie Ihre Evaluierungsaufgabe durch:
+ SageMaker 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 S3-Speicherort aus. Jede Zeile enthält die Auswertungsergebnisse 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: In der Regel 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)
### Leistungsmaßstäbe
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.
## Fehlerbehebung
### Häufige Probleme
| Problem | Ursache | Lösung |
| --- | --- | --- |
| Lambda-Zeitüberschreitung | Komplexe Prämienberechnung | Lambda-Timeout erhöhen oder Funktion optimieren |
| Erlaubnis verweigert | Fehlende IAM-Berechtigungen | Stellen Sie sicher, dass die SageMaker Rolle Lambda aufrufen kann |
| Inkonsistente Ergebnisse | Nichtdeterministische Belohnungsfunktion | Verwenden Sie feste Ausgangswerte oder deterministische Logik |
| Fehlende Ergebnisse | Lambda-Fehler wurden nicht erkannt | Fügen Sie eine umfassende Fehlerbehandlung in Lambda hinzu |
### Checkliste zum Debuggen
+ Stellen Sie sicher, dass die Eingabedaten bei verschachtelten Inhaltsarrays das richtige Format haben
+ Bestätigen Sie, dass der Lambda-ARN korrekt ist und die Funktion bereitgestellt wurde
+ Überprüfen Sie die IAM-Berechtigungen für den SageMaker → Lambda-Aufruf
+ Überprüfen Sie die CloudWatch Protokolle auf Lambda-Fehler
+ Überprüfen Sie, ob die Lambda-Antwort dem erwarteten Format entspricht
## Best Practices
+ Einfach starten: Beginnen Sie mit den grundlegenden Belohnungsfunktionen und wiederholen Sie den Vorgang
+ Lambda separat testen: Verwenden Sie Lambda-Testereignisse vor der vollständigen Auswertung
+ Bei kleinem Datensatz validieren: Führen Sie die Auswertung für eine Teilmenge vor dem vollständigen Datensatz durch
+ Versionskontrolle: Verfolgen Sie die Versionen der Belohnungsfunktionen zusammen mit den Modellversionen
+ Kosten überwachen: Lambda-Aufrufe und Rechenzeit wirken sich auf die Kosten aus
+ Umfangreich protokollieren: Verwenden Sie Print-Anweisungen in Lambda zum Debuggen
+ Richten Sie die Timeouts angemessen ein: Balance zwischen Geduld und Kosten
+ Dokumentieren Sie Kennzahlen: Definieren Sie klar, was jede Metrik misst
## Nächste Schritte
Nach Abschluss der RFT-Evaluierung:
+ Wenn die Ergebnisse zufriedenstellend sind: Modell in der Produktion einsetzen
+ Falls eine Verbesserung erforderlich ist:
+ Passen Sie die Belohnungsfunktion an
+ Sammle mehr Trainingsdaten
+ Ändern Sie die Trainingshyperparameter
+ Führen Sie zusätzliche RFT-Trainingsiterationen aus
+ Kontinuierliche Überwachung: Regelmäßige Neubewertung anhand neuer Daten
# Implementierung von Belohnungsfunktionen
## -Übersicht
Die Belohnungsfunktion (auch Scorer oder Grader genannt) ist die Kernkomponente, die Modellantworten auswertet und Feedbacksignale für das Training liefert. Sie muss als Lambda-Funktion implementiert werden, die Modellantworten akzeptiert und Belohnungspunkte zurückgibt.
## Format der Schnittstelle
Ihre Prämienfunktion muss Daten im folgenden Format akzeptieren und zurückgeben:
**Beispiel für ein Eingabebeispiel für das Training**
```
{
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**Beispielnutzlast für das Belohnungs-Lambda**
Der Container transformiert Ihre Daten automatisch, bevor er sie an Ihre Lambda-Funktion sendet, indem er:
1. Generieren einer Modellantwort für jede Aufforderung
1. Der Turn des Assistenten (generierte Antwort) wird an das Nachrichten-Array angehängt
1. Ein eindeutiges `id` Feld für die Nachverfolgung hinzufügen
Ihre Lambda-Funktion empfängt Daten in diesem transformierten Format:
```
{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don not have a dedicated security team..."
}
],
# Following section will be same as your training dataset sample
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
```
**Lambda-Vertrag belohnen**
```
def lambda_handler(event, context):
return lambda_grader(event)
def lambda_grader(samples: list[dict]) -> list[dict]:
"""
Args:
samples: List of dictionaries in OpenAI format
Example input:
{
"id": "123",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Company, I don nott have a dedicated security team..."
}
],
# This section will be same as your training dataset
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
}
}
Returns:
List of dictionaries with reward scores:
{
"id": str, # Same id as input sample
"aggregate_reward_score": float, # Overall score for the sample
"metrics_list": [ # OPTIONAL: Component scores
{
"name": str, # Name of the component score
"value": float, # Value of the component score
"type": str # "Reward" or "Metric"
}
]
}
"""
```
## Eingabe- und Ausgabefelder
### Eingabefelder
| Feld | Description | Weitere Hinweise |
| --- | --- | --- |
| id | Eindeutiger Bezeichner für die Probe | In der Ausgabe wiedergegeben. Zeichenkettenformat |
| messages | Chatverlauf im OpenAI-Format bestellt | Reihe von Nachrichtenobjekten |
| nachrichten [] .role | Sprecher der Nachricht | Allgemeine Werte: „Benutzer“, „Assistent“, „System“ |
| nachrichten [] .content | Textinhalt der Nachricht | Einfache Zeichenfolge |
| \$1\$1Metadaten | Informationen in freier Form zur Unterstützung der Benotung | Objekt; optionale Felder, die aus Trainingsdaten übernommen wurden |
### Ausgabefelder
| Feld | Description | Weitere Hinweise |
| --- | --- | --- |
| id | Derselbe Bezeichner wie beim Eingabebeispiel | Muss mit der Eingabe übereinstimmen |
| aggregate\$1reward\$1score | Gesamtpunktzahl für die Stichprobe | Float (z. B. 0,0—1,0 oder aufgabendefinierter Bereich) |
| metrics\$1list | Die Werte der Komponenten, aus denen sich das Aggregat zusammensetzt | Anordnung metrischer Objekte |
## Technische Einschränkungen
+ **Timeout-Limit** — maximale Ausführungszeit von 15 Minuten pro Lambda-Aufruf
+ **Parallelität — Muss gleichzeitige** Anfragen bearbeiten `rollout_worker_replicas * 64`
+ **Zuverlässigkeit** — Muss eine angemessene Fehlerbehandlung implementieren und konsistent gültige Ergebnisse zurückgeben
+ **Leistung** — Optimiere für eine schnelle Ausführung (Sekunden, nicht Minuten), um effizientes Training zu ermöglichen
**Best Practices**
+ Minimiere externe API-Aufrufe
+ Verwenden Sie effiziente Algorithmen und Datenstrukturen
+ Implementieren Sie eine Wiederholungslogik für vorübergehende Fehler
+ Wiederverwendbare Berechnungen zwischenspeichern
+ Testen Sie vor dem Training gründlich, um eine fehlerfreie Ausführung sicherzustellen
## Verwenden von benutzerdefinierten Belohnungsfunktionen
Implementieren Sie benutzerdefinierte Belohnungsfunktionen, wenn Sie aufgabenspezifische Bewertungskriterien haben:
+ **Definieren Sie Bewertungskriterien** — Ermitteln Sie, was eine gute Antwort auf Ihre Aufgabe ausmacht
+ **Lambda-Funktion implementieren** — Erstellen Sie eine Lambda-Funktion im Schnittstellenformat
+ **Lokal testen** — Stellen Sie sicher, dass Ihre Funktion korrekte Werte für Beispieleingaben zurückgibt
+ **Bereitstellen auf AWS** — Stellen Sie Ihr Lambda bereit und notieren Sie sich den ARN
+ **Rezept konfigurieren** — Fügen Sie den Lambda-ARN zum Feld Ihres Rezepts `reward_lambda_arn` hinzu
+ **Test mit kleinem Datensatz** — Führen Sie RFT mit minimalen Daten aus, um die Integration zu überprüfen
## IAM-Berechtigungen
### Erforderliche Berechtigungen
Ihre SageMaker Ausführungsrolle muss über Berechtigungen zum Aufrufen Ihrer Lambda-Funktion verfügen. Fügen Sie diese Richtlinie zu Ihrer SageMaker 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. S3 für Referenzdaten, DynamoDB für die Protokollierung), fügen Sie diese Berechtigungen der Lambda-Ausführungsrolle hinzu.
## Beispiel: LLM als Prämienfunktion für Richter
Dieses Beispiel zeigt, wie Amazon Bedrock-Modelle als Richter verwendet werden, um Modellantworten zu bewerten, indem sie mit Referenzantworten verglichen werden. Diese Lambda-Vorlage bietet Kunden ein Framework, mit dem sie Aufrufe an Amazon Bedrock für Inferenzanfragen zur Verarbeitung von Richterbeurteilungen implementieren können. Die Lambda-Funktion behält den gleichen input/output Vertrag wie andere Belohnungsfunktionen bei.
### Implementierung
Diese Lambda-Funktion implementiert einen zweistufigen Bewertungsprozess: Sie `lambda_handler` extrahiert Modellantworten und Referenzantworten aus eingehenden Stichproben. Anschließend ruft die `lambda_graded` Funktion Amazon Bedrock auf, um die semantische Ähnlichkeit zwischen ihnen zu bewerten. Die Implementierung umfasst eine robuste Fehlerbehandlung mit automatischen Wiederholungsversuchen bei vorübergehenden Fehlern und unterstützt flexible Referenzantwortformate (sowohl Zeichenketten- als auch strukturierte Wörterbuchformate).
**Einzelheiten der Implementierung:**
+ **Retry Logic**: Implementiert exponentielles Backoff (1s, 2s, 4s) zur Drosselung von Ausnahmen, um Bedrock-API-Ratenbegrenzungen zu umgehen
+ **Fehlerbehandlung: Gibt für fehlgeschlagene** Auswertungen einen Wert von 0,0 zurück, anstatt Ausnahmen auszulösen
+ **Deterministische Bewertung**: Verwendet Temperatur=0,0, um konsistente Ergebnisse bei allen Bewertungen sicherzustellen
+ **Flexibles Referenzformat**: Verarbeitet automatisch Antworten auf Zeichenketten und Wörterbuchreferenzen
+ **Punktebegrenzung**: Stellt sicher, dass alle Ergebnisse innerhalb des gültigen Bereichs [0,0, 1,0] liegen
+ **Modellunabhängig**: Ändern Sie JUDGE\$1MODEL\$1ID, um ein beliebiges Amazon Bedrock-Modell (Nova, Llama, Mistral usw.) zu verwenden
```
"""
LLM Judge Lambda POC - Working implementation using Amazon Bedrock
"""
import json
import time
import boto3
bedrock_runtime = boto3.client('bedrock-runtime', region_name='us-east-1')
JUDGE_MODEL_ID = "anthropic.claude-3-5-sonnet-20240620-v1:0"
SYSTEM_PROMPT = "You must output ONLY a number between 0.0 and 1.0. No explanations, no text, just the number."
JUDGE_PROMPT_TEMPLATE = """Compare the following two responses and rate how similar they are on a scale of 0.0 to 1.0, where:
- 1.0 means the responses are semantically equivalent (same meaning, even if worded differently)
- 0.5 means the responses are partially similar
- 0.0 means the responses are completely different or contradictory
Response A: {response_a}
Response B: {response_b}
Output ONLY a number between 0.0 and 1.0. No explanations."""
def lambda_graded(response_a: str, response_b: str, max_retries: int = 3) -> float:
"""Call Bedrock to compare responses and return similarity score."""
prompt = JUDGE_PROMPT_TEMPLATE.format(response_a=response_a, response_b=response_b)
for attempt in range(max_retries):
try:
response = bedrock_runtime.converse(
modelId=JUDGE_MODEL_ID,
messages=[{"role": "user", "content": [{"text": prompt}]}],
system=[{"text": SYSTEM_PROMPT}],
inferenceConfig={"temperature": 0.0, "maxTokens": 10}
)
print(f"Bedrock call successful: {response}")
output = response['output']['message']['content'][0]['text'].strip()
score = float(output)
print(f"Score parsed: {score}")
return max(0.0, min(1.0, score))
except Exception as e:
if "ThrottlingException" in str(e) and attempt < max_retries - 1:
time.sleep(2 ** attempt)
else:
print(f"Bedrock call failed: {e}")
return None
return None
def lambda_handler(event, context):
"""AWS Lambda handler - processes samples from RFTEvalInvoker."""
try:
samples = event if isinstance(event, list) else [event]
results = []
for sample in samples:
sample_id = sample.get("id", "unknown")
messages = sample.get("messages", [])
# Extract assistant response (response A)
response_a = ""
for msg in messages:
if msg.get("role") in ["assistant", "nova_assistant"]:
response_a = msg.get("content", "")
break
# Extract reference answer from root level (no longer in metadata)
reference_answer = sample.get("reference_answer", "")
# Handle both string and dict reference_answer formats
if isinstance(reference_answer, dict):
# If reference_answer is a dict, extract the explanation or compliant field
response_b = reference_answer.get("explanation", reference_answer.get("compliant", ""))
else:
response_b = reference_answer
if not response_a or not response_b:
results.append({
"id": sample_id,
"aggregate_reward_score": 0.0,
"metrics_list": [{"name": "similarity_score", "value": 0.0, "type": "Metric"}]
})
continue
# Get similarity score
score = lambda_graded(response_a, response_b)
results.append({
"id": sample_id,
"aggregate_reward_score": score,
"metrics_list": [
{
"name": "similarity_score",
"value": score,
"type": "Metric"
}
]
})
return {"statusCode": 200, "body": json.dumps(results)}
except Exception as e:
print(f"Error: {e}")
return {"statusCode": 500, "body": json.dumps({"error": str(e)})}
```
### Eingabeformat
Das Lambda erhält dasselbe Eingabeformat wie andere Belohnungsfunktionen:
```
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": "Do you have a dedicated security team?"
},
{
"role": "assistant",
"content": "As an AI developed by Amazon, I don't have a dedicated security team..."
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team..."
},
"my_custom_field": "custom_value"
}
```
### Ausgabeformat
```
{
"id": "sample-001",
"aggregate_reward_score": 0.85,
"metrics_list": [
{
"name": "similarity_score",
"value": 0.85,
"type": "Metric"
}
]
}
```
### Überlegungen zur Bereitstellung
Möglicherweise müssen Sie auch die Eingabeaufforderungsvorlage und die Inferenzparameter an die Funktionen und das API-Format Ihres ausgewählten Modells anpassen.
+ **IAM-Berechtigungen**: Die Lambda-Ausführungsrolle muss über `bedrock:InvokeModel` Berechtigungen für das von Ihnen gewählte Modell verfügen
+ **Timeout**: Legen Sie das Lambda-Timeout auf mindestens 60 Sekunden fest, um der Bedrock-API-Latenz und den Wiederholungsversuchen Rechnung zu tragen
+ **Region**: In einer Region einsetzen, in der das von Ihnen gewählte Bedrock-Modell verfügbar ist
+ **Kosten**: Überwachen Sie die Bedrock-API-Nutzung, da bei jeder Evaluierung ein API-Aufruf pro Probe erfolgt
+ **Durchsatz**: Fordern Sie für umfangreiche Evaluationen erhöhte Bedrock-Kontingente an, um Drosselungen zu vermeiden
**Erhöhung des Durchsatzes im Grundgestein**
Wenn Sie während der Evaluierung eine Drosselung feststellen, erhöhen Sie die Kontingente für Ihr Bedrock-Modell:
+ Navigieren Sie zur AWS Service Quotas Quotas-Konsole.
+ Suchen Sie nach „Bedrock“ und wählen Sie Ihre Region aus
+ Finden Sie das Kontingent für das von Ihnen gewählte Modell heraus (zum Beispiel „Aufrufe pro Minute für Claude 3.5 Sonnet“)
+ Klicken Sie auf „Erhöhung des Kontingents beantragen“ und geben Sie den gewünschten Durchsatz an
+ Begründen Sie die Erhöhung (z. B. „Arbeitsaufwand bei der RFT-Evaluierung“)
Die integrierte Wiederholungslogik von Lambda verarbeitet gelegentliche Drosselungen, aber dauerhaft umfangreiche Auswertungen erfordern angemessene Quotenerhöhungen.
**Erforderliche IAM-Richtlinie:**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": "arn:aws:bedrock:*::foundation-model/*"
}
]
}
```