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) + [Iteratives Training](smtj-iterative-training.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-lite-v1:0:300k model_name_or_path: nova-lite/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 (Modell Nova 2.0 — siehe Anleitung zur Anpassung von Nova 2.0)](https://docs.aws.amazon.com//nova/latest/nova2-userguide/nova-model.html) + `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 (Modell Nova 2.0) + 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 Inferenzen (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 allgemeine Fragen und Antworten 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/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 Funktion zur Modellbewertung, 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. ## 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, ob die 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) + [Iteratives Training](smtj-iterative-training.md)