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.
# Amazon Nova-Anpassung auf SageMaker HyperPod
Sie können Amazon Nova-Modelle, einschließlich der erweiterten Amazon Nova 2.0-Modelle, mithilfe von [Amazon Nova-Rezepten](nova-model-recipes.md) anpassen und sie auf Hyperpod trainieren. Ein Rezept ist eine YAML-Konfigurationsdatei, die der SageMaker KI Einzelheiten zur Ausführung Ihrer Modellanpassung zur Verfügung stellt. SageMaker HyperPod unterstützt zwei Arten von Diensten: Forge und Non-Forge.
Hyperpod bietet Hochleistungsdatenverarbeitung mit optimierten GPU-Instances und Amazon FSx for Lustre-Speicher, robuste Überwachung durch Integration mit Tools wie TensorBoard flexiblem Checkpoint-Management für iterative Verbesserungen, nahtlose Bereitstellung auf Amazon Bedrock für Inferenz und effizientes, skalierbares verteiltes Training mit mehreren Knoten — alles zusammen bietet Unternehmen eine sichere, leistungsstarke und flexible Umgebung, in der sie Amazon Nova-Modelle an ihre spezifischen Geschäftsanforderungen anpassen können.
Amazon Nova-Anpassung an SageMaker HyperPod speichert Modellartefakte, einschließlich Modell-Checkpoints, in einem serviceverwalteten Amazon S3 S3-Bucket. Artefakte im vom Service verwalteten Bucket werden mit SageMaker KI-verwalteten Schlüsseln verschlüsselt. AWS KMS Serviceverwaltete Amazon-S3-Buckets unterstützen derzeit keine Datenverschlüsselung mit kundenverwalteten KMS-Schlüsseln. Sie können diesen Checkpoint-Standort für Bewertungsjobs oder Amazon-Bedrock-Inferenz verwenden.
Standardpreise können für Compute-Instances, Amazon S3 S3-Speicher und FSx für Lustre gelten. Preisinformationen finden Sie unter [Hyperpod-Preise](https://aws.amazon.com/sagemaker-ai/pricing/), [Amazon S3 S3-Preise](https://aws.amazon.com/s3/pricing/) und [FSx Lustre-Preise](https://aws.amazon.com/fsx/lustre/pricing/).
## Rechenanforderungen für Amazon Nova 2-Modelle
In den folgenden Tabellen sind die Rechenanforderungen für SageMaker HyperPod und die Ausbildung von SageMaker KI-Schulungsjobs für Amazon Nova 2-Modelle zusammengefasst.
**Nova 2-Schulungsanforderungen**
| Trainingstechnik | Minimale Anzahl von Instanzen | Instance-Typ | Anzahl der GPUs | Hinweise | Unterstützte Modelle |
| --- |--- |--- |--- |--- |--- |
| SFT (LoRa) | 4 | P 5.48 x groß | 16 | Parametereffiziente Feinabstimmung | Nova 2 Lite |
| SFT (voller Rang) | 4 | P 5.48 x groß | 32 | Vollständige Feinabstimmung des Modells | Nova 2 Lite |
| RFT für SageMaker Ausbildungsberufe (LoRa) | 2 | P5.48 x groß | 16 | Benutzerdefinierte Belohnungsfunktionen in Ihrer Umgebung AWS | Nova 2 Lite |
| RFT für SageMaker Ausbildungsberufe (voller Rang) | 4 | P 5.48 x groß | 32 | Länge des Kontextes 32 KB | Nova 2 Lite |
| RFT ein SageMaker HyperPod | 8 | P 5.48 x groß | 64 | Standardkontextlänge 8192 | Nova 2 Lite |
| CPT | 4 | P 5.48 x groß | 16 | Verarbeitet ungefähr 400 Millionen Token pro Instanz und Tag | Nova 2 Lite |
Um Ihre Workflows zur Anpassung Ihrer Amazon Nova-Modelle auf Hyperpod zu optimieren, befolgen Sie diese empfohlenen Best Practices für effizientes Training, Ressourcenmanagement und erfolgreiche Modellbereitstellung.
## Bewährte Methoden für die Anpassung von Amazon Nova
### -Übersicht
Dieser Abschnitt bietet einen Überblick über Anpassungstechniken und hilft Ihnen bei der Auswahl des besten Ansatzes für Ihre Bedürfnisse und verfügbaren Daten.
#### Zwei Phasen der LLM-Ausbildung
Das Training mit großen Sprachmodellen besteht aus zwei Hauptphasen: vor dem Training und nach dem Training. Während des Trainings vor dem Training verarbeitet das Modell Tokens mit Rohtext und optimiert es für die Vorhersage des nächsten Tokens. Dieser Prozess erstellt einen Mustervervollständiger, der Syntax, Semantik, Fakten und Argumentationsmuster aus dem Internet und kuratiertem Text aufnimmt. Das vortrainierte Modell versteht jedoch Anweisungen, Benutzerziele oder kontextgerechtes Verhalten nicht. Es setzt den Text in dem Stil fort, der zu seiner Schulungsstruktur passt. Ein vorab trainiertes Modell vervollständigt die Anweisungen automatisch, statt sie zu befolgen, erzeugt eine inkonsistente Formatierung und kann unerwünschte Verzerrungen oder unsichere Inhalte aus den Trainingsdaten wiedergeben. Vor dem Training werden allgemeine Kompetenzen vermittelt, nicht die Nützlichkeit der Aufgaben.
Nach dem Training wird der Mustervervollständiger zu einem nützlichen Assistenten. Sie führen mehrere Runden Supervised Fine-Tuning (SFT) durch, um dem Modell beizubringen, Anweisungen zu befolgen, Schemata und Richtlinien einzuhalten, Tools aufzurufen und zuverlässige Ergebnisse zu erzielen, indem hochwertige Demonstrationen nachgeahmt werden. Durch diese Ausrichtung lernt das Modell, auf Eingabeaufforderungen als Aufgaben und nicht als Text zu reagieren, um fortzufahren. Anschließend wenden Sie Reinforcement Fine-Tuning (RFT) an, um das Verhalten mithilfe von messbarem Feedback (z. B. Prüfer oder einem LLM-as-a-judge) zu optimieren und dabei Kompromisse wie Genauigkeit und Kürze, Sicherheit versus Reichweite oder mehrstufiges Denken unter Berücksichtigung von Einschränkungen abzuwägen. In der Praxis wechseln Sie SFT und RFT zyklisch ab, um aus dem vorab trainierten Modell ein zuverlässiges, richtliniengerechtes System zu machen, das komplexe Aufgaben konsistent ausführt.
### Wählen Sie den richtigen Anpassungsansatz
In diesem Abschnitt werden wir uns mit Strategien zur Anpassung nach dem Training befassen: RFT und SFT.
#### Feinabstimmung der Verstärkung (RFT)
Die Feinabstimmung der Verstärkung verbessert die Modellleistung durch Feedbacksignale — messbare Werte oder Belohnungen, die auf die Qualität der Antworten hinweisen — und nicht durch direkte Überwachung mit exakt richtigen Antworten. Im Gegensatz zur herkömmlichen überwachten Feinabstimmung, die aus Input-Output-Paaren lernt, verwendet RFT Belohnungsfunktionen, um die Modellantworten zu bewerten, und optimiert das Modell iterativ, um diese Belohnungen zu maximieren. Dieser Ansatz eignet sich gut für Aufgaben, bei denen es schwierig ist, den exakt richtigen Output zu definieren, aber Sie können die Qualität der Antworten zuverlässig messen. RFT ermöglicht es Modellen, komplexe Verhaltensweisen und Präferenzen durch Versuche und Feedback zu erlernen, und eignet sich daher ideal für Anwendungen, die eine differenzierte Entscheidungsfindung, kreative Problemlösung oder die Einhaltung bestimmter Qualitätskriterien erfordern, die Sie programmgesteuert auswerten können. Die Beantwortung komplexer Rechtsfragen ist beispielsweise ein idealer Anwendungsfall für RFT, da Sie dem Modell beibringen möchten, besser zu argumentieren, um Fragen genauer zu beantworten.
##### Funktionsweise
Bei der Feinabstimmung von Verstärkungen gehen Sie von einer auf Anweisungen abgestimmten Ausgangsbasis aus und behandeln jede Aufforderung wie ein kleines Turnier. Für eine bestimmte Eingabe nehmen Sie eine Stichprobe von einer Handvoll Kandidatenantworten aus dem Modell, bewerten jede einzelne mit der Belohnungsfunktion und ordnen sie dann innerhalb dieser Gruppe ein. Durch den Aktualisierungsschritt wird das Modell so angepasst, dass beim nächsten Mal die Wahrscheinlichkeit von Kandidaten mit einer höheren Punktzahl und die Wahrscheinlichkeit von Kandidaten mit niedrigerer Punktzahl geringer wird, während eine stay-close-to-baseline Einschränkung verhindert, dass das Verhalten abdriftet, ausführlich oder ausbeuterisch wird. Sie wiederholen diesen Vorgang bei vielen Eingabeaufforderungen, aktualisieren schwierige Fälle, verschärfen die Rubriken für Prüfer oder Richter, wenn Sie Exploits sehen, und verfolgen kontinuierlich die Aufgabenmetriken.
##### Wann sollte RFT verwendet werden
Aufgaben, die am meisten von RFT profitieren, haben mehrere Merkmale gemeinsam. Sie haben messbare Erfolgssignale, auch wenn es schwierig ist, eine einzelne korrekte Ausgabe zu spezifizieren. Sie geben teilweise Anerkennung oder benotete Qualität, sodass Sie innerhalb einer Aufforderung oder mithilfe einer Belohnungsfunktion bessere oder schlechtere Antworten bewerten können. Sie beinhalten mehrere Ziele, die gegeneinander abgewogen werden müssen (z. B. Genauigkeit und Kürze, Klarheit, Sicherheit oder Kosten). Sie erfordern die Einhaltung ausdrücklicher Einschränkungen, die Sie programmgesteuert überprüfen können. Sie funktionieren in toolgestützten oder umgebungsbasierten Umgebungen, in denen Ergebnisse beobachtbar sind (Erfolg oder Misserfolg, Latenz, Ressourcennutzung). Sie treten in Ländern auf, in denen das Sammeln von Goldzielen teuer ist, aber automatisiertes oder rubrikbasiertes Feedback in Hülle und Fülle vorhanden ist. RFT funktioniert am besten, wenn Sie Qualität in einen zuverlässigen Skalar oder ein zuverlässiges Ranking umwandeln können und möchten, dass das Modell Verhaltensweisen mit höheren Punktzahlen bevorzugt verstärkt, ohne dass erschöpfende, beschriftete Ziele erforderlich sind.
**Ziehen Sie andere Methoden in Betracht, wenn:**
+ Sie haben zahlreiche, zuverlässig beschriftete Eingangs-/Ausgangspaare — verwenden Sie SFT
+ Die größte Lücke ist Wissen oder Fachjargon — nutzen Sie Retrieval-Augmented Generation (RAG)
+ Dein Belohnungssignal ist verrauscht oder unzuverlässig und du kannst es nicht mit besseren Rubriken oder Checkern beheben. Stabilisiere das zuerst, bevor du RFT
##### Wann sollte RFT nicht verwendet werden
Vermeiden Sie RFT in diesen Situationen:
+ Sie können kostengünstig zuverlässige, beschriftete Eingangs-/Ausgangspaare herstellen (SFT ist einfacher, billiger und stabiler)
+ Die Lücke ist eher Wissen oder Fachjargon als Verhalten (verwenden Sie RAG)
+ Ihr Belohnungssignal ist laut, spärlich, einfach zu spielen oder teuer oder langsam zu berechnen (korrigieren Sie zuerst den Evaluator)
+ Die Ausgangsleistung liegt nahe Null (zuerst mit SFT starten, bevor die Einstellungen optimiert werden)
+ Die Aufgabe hat deterministische Schemata, eine strikte Formatierung oder eine einzige richtige Antwort (SFT oder regelbasierte Validierung funktioniert besser)
+ Enge Latenz- oder Kostenbudgets können die zusätzlichen Probenahme- oder Explorationskosten, die RFT erfordert, nicht auffangen
+ Sicherheits- oder politische Einschränkungen sind in der Prämie nicht klar spezifiziert und durchsetzbar
Wenn Sie auf „die richtige Antwort“ hinweisen können, verwenden Sie SFT. Wenn Sie neues Wissen benötigen, verwenden Sie RAG. Verwenden Sie RFT erst, wenn Sie eine solide Ausgangsbasis und eine robuste, schnelle hard-to-exploit Belohnungsfunktion haben.
#### Überwachte Optimierung (SFT)
Die überwachte Feinabstimmung trainiert das LLM anhand eines Datensatzes von Input-Output-Paaren, die von Menschen beschriftet wurden, für Ihre Aufgabe. Sie geben Beispiele für Eingabeaufforderungen (Fragen, Anweisungen usw.) mit den richtigen oder gewünschten Antworten und setzen das Training des Modells anhand dieser Beispiele fort. Das Modell passt seine Gewichtungen an, um einen überwachten Verlust zu minimieren (in der Regel eine Kreuzentropie zwischen seinen Vorhersagen und den Ziel-Output-Token). Dabei handelt es sich um dasselbe Training, das bei den meisten Aufgaben des überwachten maschinellen Lernens zur Spezialisierung eines LLM verwendet wird.
SFT verändert Verhalten, nicht Wissen. Es bringt dem Modell keine neuen Fakten oder Fachjargon bei, die es vor dem Training nicht gesehen hat. Es bringt dem Modell bei, wie man antwortet, nicht, was es wissen soll. Wenn Sie neues Fachwissen benötigen (z. B. interne Terminologie), verwenden Sie Retrieval-Augmented Generation (RAG), um diesen Kontext zum Zeitpunkt der Inferenz bereitzustellen. SFT fügt dann das gewünschte Verhalten bei der Befolgung von Anweisungen hinzu.
##### Funktionsweise
SFT optimiert LLM, indem es den durchschnittlichen Kreuzentropieverlust bei Antwort-Token minimiert, Prompt-Token als Kontext behandelt und sie vor dem Verlust maskiert. Das Modell verinnerlicht Ihren Zielstil, Ihre Struktur und Ihre Entscheidungsregeln und lernt, für jede Aufforderung die richtige Antwort zu generieren. Um Dokumente beispielsweise in benutzerdefinierte Kategorien zu klassifizieren, optimieren Sie das Modell mithilfe von Eingabeaufforderungen (dem Dokumenttext) und beschrifteten Vervollständigungen (den Kategoriebeschriftungen). Sie trainieren mit diesen Paaren, bis das Modell für jede Aufforderung mit hoher Wahrscheinlichkeit die richtige Bezeichnung ausgibt.
Sie können SFT mit nur ein paar hundert Beispielen durchführen und bis zu einigen hunderttausend skalieren. SFT-Proben müssen von hoher Qualität sein und direkt auf das gewünschte Modellverhalten abgestimmt sein.
##### Wann sollte SFT verwendet werden
Verwenden Sie SFT, wenn Sie eine klar definierte Aufgabe mit eindeutig gewünschten Ergebnissen haben. Wenn Sie explizit angeben können, dass „Bei gegebener X-Eingabe ist die richtige Ausgabe Y“ und Beispiele für solche Zuordnungen sammeln können, ist die überwachte Feinabstimmung eine gute Wahl. SFT zeichnet sich in diesen Szenarien aus:
+ **Strukturierte oder komplexe Klassifizierungsaufgaben** — Klassifizieren Sie interne Dokumente oder Verträge in viele benutzerdefinierte Kategorien. Mit SFT lernt das Modell diese spezifischen Kategorien besser kennen, als wenn es nur Eingabeaufforderungen erfordert.
+ **Beantwortung von Fragen oder Transformationsaufgaben mit bekannten Antworten** — Optimieren Sie ein Modell, um Fragen aus der Wissensdatenbank eines Unternehmens zu beantworten, oder konvertieren Sie Daten zwischen Formaten, bei denen jede Eingabe eine richtige Antwort hat.
+ **Einheitlichkeit bei Formatierung und Stil** — Trainieren Sie das Modell so, dass es immer in einem bestimmten Format oder Ton reagiert, indem Sie anhand von Beispielen für das richtige Format oder den richtigen Ton Feinabstimmungen vornehmen. Wenn das Modell beispielsweise anhand von Paaren zwischen Aufforderung und Antwort trainiert wird, die eine bestimmte Markensprache zum Ausdruck bringen, wird dem Modell beigebracht, Outputs mit diesem Stil zu generieren. Verhalten, das Anweisungen befolgt, wird häufig zunächst durch SFT anhand von kuratierten Beispielen für gutes Verhalten von Assistenten vermittelt.
SFT ist der direkteste Weg, einem LLM eine neue Fähigkeit oder ein neues Verhalten beizubringen, wenn Sie angeben können, wie das richtige Verhalten aussieht. Es nutzt das vorhandene Sprachverständnis des Modells und konzentriert es auf Ihre Aufgabe. Verwenden Sie SFT, wenn Sie möchten, dass das Modell eine bestimmte Aufgabe erfüllt und Sie einen Datensatz mit Beispielen haben oder erstellen können.
Verwenden Sie SFT, wenn Sie qualitativ hochwertige Eingabeaufforderungs- und Antwortpaare zusammenstellen können, die das gewünschte Verhalten genau widerspiegeln. Es eignet sich für Aufgaben mit klaren Zielen oder deterministischen Formaten wie Schemas, Funktions- oder Toolaufrufen sowie für strukturierte Antworten, bei denen Nachahmung ein geeignetes Trainingssignal ist. Das Ziel ist die Verhaltensformung: Dem Modell beizubringen, Eingabeaufforderungen als Aufgaben zu behandeln, Anweisungen zu befolgen, Ton- und Ablehnungsrichtlinien anzunehmen und eine einheitliche Formatierung zu gewährleisten. Planen Sie mindestens Hunderte von Demonstrationen ein, bei denen Datenqualität, Konsistenz und Deduplizierung wichtiger sind als das reine Volumen. Verwenden Sie für ein unkompliziertes, kosteneffizientes Update parametereffiziente Methoden wie Low-Rank Adaptation, um kleine Adapter zu trainieren und dabei den Großteil des Backbones unangetastet zu lassen.
##### Wann sollte SFT nicht verwendet werden
Verwenden Sie SFT nicht, wenn die Lücke eher im Wissen als im Verhalten besteht. Es vermittelt dem Modell keine neuen Fakten, Fachjargon oder aktuelle Ereignisse. Verwenden Sie in diesen Fällen die Generierung mit erweitertem Abruf, um externes Wissen als Inferenz heranzuziehen. Vermeiden Sie SFT, wenn Sie die Qualität messen können, aber keine einzige richtige Antwort angeben können. Verwenden Sie die Feinabstimmung der Verstärkung mit überprüfbaren Belohnungen oder einer, um diese Prämien LLM-as-a-judge direkt zu optimieren. Wenn sich Ihre Bedürfnisse oder Inhalte häufig ändern, verlassen Sie sich auf den Abruf und die Verwendung von Tools, anstatt das Modell erneut zu trainieren.
**Topics**
+ [Rechenanforderungen für Amazon Nova 2-Modelle](#nova-hp-compute-2)
+ [Bewährte Methoden für die Anpassung von Amazon Nova](#best-practices)
+ [Nova Forge SDK](nova-hp-forge-sdk.md)
+ [Erstellen eines SageMaker HyperPod EKS-Clusters mit eingeschränkter Instanzgruppe (RIG)](nova-hp-cluster.md)
+ [Leitfaden SageMaker HyperPod für Amazon Essential Commands](nova-hp-essential-commands-guide.md)
+ [Zugang und Einrichtung von Nova Forge für](nova-forge-hp-access.md)
+ [Schulung für Amazon Nova-Modelle](nova-hp-training.md)
+ [Bewerten Ihres trainierten Modells](nova-hp-evaluate.md)
+ [HyperPod Überwachung von Aufträgen mit MLflow](nova-hp-mlflow.md)
# Nova Forge SDK
Das Amazon Nova Forge SDK ist ein umfassendes Python-SDK, das eine einheitliche, programmatische Oberfläche für den gesamten Lebenszyklus der Amazon Nova-Modellanpassung bietet. Das SDK vereinfacht die Modellanpassung, indem es eine einzige, konsistente API für Training, Bewertung, Überwachung, Bereitstellung und Inferenz auf den Plattformen Amazon SageMaker und Amazon Bedrock bietet.
Weitere Informationen finden Sie unter [Nova Forge SDK](nova-forge-sdk.md).
# Erstellen eines SageMaker HyperPod EKS-Clusters mit eingeschränkter Instanzgruppe (RIG)
Um ein Modell auf Hyperpod anzupassen, muss die erforderliche Infrastruktur eingerichtet werden. Einzelheiten zur Einrichtung eines SageMaker HyperPod EKS-Clusters mit einer eingeschränkten Instanzgruppe (RIG) finden Sie im [Workshop](https://catalog.us-east-1.prod.workshops.aws/workshops/dcac6f7a-3c61-4978-8344-7535526bf743/en-US), der eine detaillierte Anleitung zum Einrichtungsprozess bietet.
# Leitfaden SageMaker HyperPod für Amazon Essential Commands
Amazon SageMaker HyperPod bietet umfangreiche Befehlszeilenfunktionen für die Verwaltung von Schulungsabläufen. Dieses Handbuch behandelt grundlegende Befehle für allgemeine Operationen, von der Verbindung mit Ihrem Cluster bis hin zur Überwachung des Auftragsfortschritts.
**Voraussetzungen**
Bevor Sie diese Befehle verwenden, stellen Sie sicher, dass Sie die folgende Einrichtung abgeschlossen haben:
+ SageMaker HyperPod Cluster mit erstelltem RIG (normalerweise in us-east-1)
+ Ausgabe eines Amazon S3 S3-Buckets, der für Trainingsartefakte erstellt wurde
+ Mit entsprechenden Berechtigungen konfigurierte IAM-Rollen
+ Trainingsdaten wurden im richtigen JSONL-Format hochgeladen
+ FSx Die Lustre-Synchronisierung ist abgeschlossen (beim ersten Job in den Cluster-Protokollen überprüfen)
**Topics**
+ [Recipe CLI installieren](#nova-hp-essential-commands-guide-install)
+ [Verbindungsaufbau mit Ihrem Cluster](#nova-hp-essential-commands-guide-connect)
+ [Einen Ausbildungsjob beginnen](#nova-hp-essential-commands-guide-start-job)
+ [Jobstatus wird überprüft](#nova-hp-essential-commands-guide-status)
+ [Jobprotokolle überwachen](#nova-hp-essential-commands-guide-logs)
+ [Aktive Jobs auflisten](#nova-hp-essential-commands-guide-list-jobs)
+ [Stornieren eines Auftrags](#nova-hp-essential-commands-guide-cancel-job)
+ [Einen Evaluierungsjob ausführen](#nova-hp-essential-commands-guide-evaluation)
+ [Häufige Probleme](#nova-hp-essential-commands-guide-troubleshooting)
## Recipe CLI installieren
Navigieren Sie zum Stammverzeichnis Ihres Rezept-Repositorys, bevor Sie den Installationsbefehl ausführen.
**Verwenden Sie das Hyperpodrecipes-Repository, wenn Sie Anpassungstechniken verwenden, die nicht von Forge stammen. Informationen zur Forge-basierten Anpassung finden Sie im Forge-spezifischen Rezept-Repository.**
Führen Sie die folgenden Befehle aus, um die SageMaker HyperPod CLI zu installieren:
**Anmerkung**
Stellen Sie sicher, dass Sie sich nicht in einer aktiven Conda/Anaconda/Miniconda-Umgebung oder einer anderen virtuellen Umgebung befinden
Wenn ja, verlassen Sie die Umgebung bitte mit:
`conda deactivate`für Conda/Anaconda/Miniconda-Umgebungen
`deactivate`für virtuelle Python-Umgebungen
Wenn Sie eine Technik zur Anpassung verwenden, die nicht von Forge stammt, laden Sie sagemaker-hyperpod-recipes sie wie folgt herunter:
```
git clone -b release_v2 https://github.com/aws/sagemaker-hyperpod-cli.git
cd sagemaker-hyperpod-cli
pip install -e .
cd ..
root_dir=$(pwd)
export PYTHONPATH=${root_dir}/sagemaker-hyperpod-cli/src/hyperpod_cli/sagemaker_hyperpod_recipes/launcher/nemo/nemo_framework_launcher/launcher_scripts:$PYTHONPATH
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
rm -f ./get_helm.sh
```
Wenn Sie ein **Forge-Abonnent sind,** sollten Sie die Rezepte mithilfe des unten genannten Verfahrens herunterladen.
```
mkdir NovaForgeHyperpodCLI
cd NovaForgeHyperpodCLI
aws s3 cp s3://nova-forge-c7363-206080352451-us-east-1/v1/ ./ --recursive
pip install -e .
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
rm -f ./get_helm.sh
```
**Tipp**
Um vor der Ausführung eine [neue virtuelle Umgebung](https://docs.python.org/3/library/venv.html) zu verwenden`pip install -e .`, führen Sie folgenden Befehl aus:
`python -m venv nova_forge`
`source nova_forge/bin/activate`
In Ihrer Befehlszeile wird nun (nova\$1forge) am Anfang Ihrer Eingabeaufforderung angezeigt
Dadurch wird sichergestellt, dass bei der Verwendung der CLI keine konkurrierenden Abhängigkeiten bestehen
**Zweck**: Warum tun wir das`pip install -e .`?
Dieser Befehl installiert die SageMaker HyperPod CLI im bearbeitbaren Modus, sodass Sie aktualisierte Rezepte verwenden können, ohne sie jedes Mal neu installieren zu müssen. Außerdem können Sie neue Rezepte hinzufügen, die von der CLI automatisch abgerufen werden können.
## Verbindungsaufbau mit Ihrem Cluster
Connect die SageMaker HyperPod CLI mit Ihrem Cluster, bevor Sie Jobs ausführen:
```
export AWS_REGION=us-east-1 && SageMaker HyperPod connect-cluster --cluster-name --region us-east-1
```
**Wichtig**
Dieser Befehl erstellt eine Kontextdatei (`/tmp/hyperpod_context.json`), die für nachfolgende Befehle erforderlich ist. Wenn Sie eine Fehlermeldung darüber erhalten, dass diese Datei nicht gefunden wurde, führen Sie den Befehl connect erneut aus.
**Profi-Tipp**: Sie können Ihren Cluster weiter so konfigurieren, dass er immer den `kubeflow` Namespace verwendet, indem Sie das `--namespace kubeflow` Argument wie folgt zu Ihrem Befehl hinzufügen:
```
export AWS_REGION=us-east-1 && \
hyperpod connect-cluster \
--cluster-name \
--region us-east-1 \
--namespace kubeflow
```
Dies erspart Ihnen den Aufwand, das `-n kubeflow` bei der Interaktion mit Ihren Jobs in jedem Befehl hinzufügen zu müssen.
## Einen Ausbildungsjob beginnen
**Anmerkung**
Wenn Sie PPO/RFT Jobs ausführen, stellen Sie sicher, dass Sie Labelauswahl-Einstellungen hinzufügen, `src/hyperpod_cli/sagemaker_hyperpod_recipes/recipes_collection/cluster/k8s.yaml` sodass alle Pods auf demselben Knoten geplant sind.
```
label_selector:
required:
sagemaker.amazonaws.com/instance-group-name:
-
```
Starten Sie einen Trainingsjob mithilfe eines Rezepts mit optionalen Parameterüberschreibungen:
```
hyperpod start-job -n kubeflow \
--recipe fine-tuning/nova/nova_1_0/nova_micro/SFT/nova_micro_1_0_p5_p4d_gpu_lora_sft \
--override-parameters '{
"instance_type": "ml.p5.48xlarge",
"container": "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:SM-HP-SFT-latest"
}'
```
**Erwartete Ausgabe**:
```
Final command: python3 /NovaForgeHyperpodCLI/src/hyperpod_cli/sagemaker_hyperpod_recipes/main.py recipes=fine-tuning/nova/nova_micro_p5_gpu_sft cluster_type=k8s cluster=k8s base_results_dir=/local/home//results cluster.pullPolicy="IfNotPresent" cluster.restartPolicy="OnFailure" cluster.namespace="kubeflow" container="708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-fine-tune-repo:HP-SFT-DATAMIX-latest"
Prepared output directory at /local/home//results//k8s_templates
Found credentials in shared credentials file: ~/.aws/credentials
Helm script created at /local/home//results//_launch.sh
Running Helm script: /local/home//results//_launch.sh
NAME:
LAST DEPLOYED: Mon Sep 15 20:56:50 2025
NAMESPACE: kubeflow
STATUS: deployed
REVISION: 1
TEST SUITE: None
Launcher successfully generated: /NovaForgeHyperpodCLI/src/hyperpod_cli/sagemaker_hyperpod_recipes/launcher/nova/k8s_templates/SFT
{
"Console URL": "https://us-east-1.console.aws.amazon.com/sagemaker/home?region=us-east-1#/cluster-management/"
}
```
## Jobstatus wird überprüft
Überwachen Sie Ihre laufenden Jobs mit kubectl:
```
kubectl get pods -o wide -w -n kubeflow | (head -n1 ; grep )
```
**Pod-Status verstehen**
In der folgenden Tabelle werden die häufigsten Pod-Status erklärt:
| Status | Description |
| --- |--- |
| `Pending` | Der Pod wurde akzeptiert, aber noch nicht für einen Knoten geplant oder wartet darauf, dass Container-Images abgerufen werden |
| `Running` | Pod, der an einen Knoten gebunden ist, auf dem mindestens ein Container läuft oder gestartet wird |
| `Succeeded` | Alle Container wurden erfolgreich abgeschlossen und können nicht neu gestartet werden |
| `Failed` | Alle Container wurden beendet, wobei mindestens einer mit einem Fehler endete |
| `Unknown` | Der Pod-Status kann nicht bestimmt werden (normalerweise aufgrund von Problemen mit der Knotenkommunikation) |
| `CrashLoopBackOff` | Wiederholter Ausfall des Containers; Kubernetes macht bei Neustartversuchen einen Rückzieher |
| `ImagePullBackOff` / `ErrImagePull` | Das Container-Image konnte nicht aus der Registrierung abgerufen werden |
| `OOMKilled` | Der Container wurde wegen Überschreitung der Speichergrenzen beendet |
| `Completed` | Job oder Pod erfolgreich abgeschlossen (Batch-Job-Abschluss) |
**Tipp**
Verwenden Sie die `-w` Flagge, um sich die Aktualisierungen des Pod-Status in Echtzeit anzusehen. Drücken Sie`Ctrl+C`, um die Wiedergabe zu beenden.
## Jobprotokolle überwachen
Sie können Ihre Protokolle auf drei Arten anzeigen:
**Verwenden CloudWatch**
Ihre Protokolle sind in Ihrem AWS Konto verfügbar, das den Hyperpodcluster unter enthält. CloudWatch Um sie in Ihrem Browser anzuzeigen, navigieren Sie in Ihrem Konto zur CloudWatch Startseite und suchen Sie nach Ihrem Clusternamen. Wenn Ihr Cluster beispielsweise aufgerufen würde, hätte `my-hyperpod-rig` die Protokollgruppe das Präfix:
+ **Protokollgruppe**: `/aws/sagemaker/Clusters/my-hyperpod-rig/{UUID}`
+ Sobald Sie in der Protokollgruppe sind, können Sie Ihr spezifisches Protokoll anhand der Knoteninstanz-ID wie - finden`hyperpod-i-00b3d8a1bf25714e4`.
+ `i-00b3d8a1bf25714e4`steht hier für den Hyperpod-freundlichen Computernamen, auf dem Ihr Trainingsjob ausgeführt wird. **Erinnern Sie sich, wie wir in der vorherigen `kubectl get pods -o wide -w -n kubeflow | (head -n1 ; grep my-cpt-run)` Befehlsausgabe eine Spalte namens NODE erfasst haben.**
+ Der „Master“ -Knoten wurde in diesem Fall auf Hyperpod `i-00b3d8a1bf25714e4` - ausgeführt. Daher verwenden wir diese Zeichenfolge, um die anzuzeigende Protokollgruppe auszuwählen. Wählen Sie den aus, der sagt `SagemakerHyperPodTrainingJob/rig-group/[NODE]`
**CloudWatch Insights verwenden**
Wenn Sie Ihren Jobnamen griffbereit haben und nicht alle oben genannten Schritte durchführen möchten, können Sie einfach alle Logs unter abfragen, `/aws/sagemaker/Clusters/my-hyperpod-rig/{UUID}` um das individuelle Protokoll zu finden.
CPT:
```
fields @timestamp, @message, @logStream, @log
| filter @message like /(?i)Starting CPT Job/
| sort @timestamp desc
| limit 100
```
Um den Auftrag abzuschließen, ersetzen Sie ihn durch `Starting CPT Job` `CPT Job completed`
Dann können Sie sich durch die Ergebnisse klicken und diejenige mit der Aufschrift „Epoche 0" auswählen, da dies Ihr Masternode sein wird.
**Mit dem AWS CLI**
Sie können wählen, ob Sie Ihre Protokolle mit dem verfolgen möchten AWS CLI. Bevor Sie dies tun, überprüfen Sie bitte Ihre AWS CLI Version mit`aws --version`. Es wird auch empfohlen, dieses Utility-Skript zu verwenden, das bei der Live-Protokollverfolgung in Ihrem Terminal hilft
**für V1**:
```
aws logs get-log-events \
--log-group-name /aws/sagemaker/YourLogGroupName \
--log-stream-name YourLogStream \
--start-from-head | jq -r '.events[].message'
```
**für V2**:
```
aws logs tail /aws/sagemaker/YourLogGroupName \
--log-stream-name YourLogStream \
--since 10m \
--follow
```
## Aktive Jobs auflisten
Alle Jobs anzeigen, die in Ihrem Cluster ausgeführt werden:
```
hyperpod list-jobs -n kubeflow
```
**Beispielausgabe:**
```
{
"jobs": [
{
"Name": "test-run-nhgza",
"Namespace": "kubeflow",
"CreationTime": "2025-10-29T16:50:57Z",
"State": "Running"
}
]
}
```
## Stornieren eines Auftrags
Stoppen Sie einen laufenden Job jederzeit:
```
hyperpod cancel-job --job-name -n kubeflow
```
**Finden Sie Ihren Jobnamen**
**Option 1: Aus deinem Rezept**
Der Jobname ist im `run` Block Ihres Rezepts angegeben:
```
run:
name: "my-test-run" # This is your job name
model_type: "amazon.nova-micro-v1:0:128k"
...
```
**Option 2: Aus dem Befehl list-jobs**
Verwenden `hyperpod list-jobs -n kubeflow` und kopieren Sie das `Name` Feld aus der Ausgabe.
## Einen Evaluierungsjob ausführen
Evaluieren Sie ein trainiertes Modell oder Basismodell anhand eines Bewertungsrezepts.
**Voraussetzungen**
Bevor Sie Evaluierungsjobs ausführen, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ Checkpoint Amazon S3 S3-URI aus der `manifest.json` Datei Ihres Trainingsjobs (für trainierte Modelle)
+ Bewertungsdatensatz wurde im richtigen Format auf Amazon S3 hochgeladen
+ Amazon S3-Pfad für Evaluierungsergebnisse ausgeben
**Befehl**
Führen Sie den folgenden Befehl aus, um einen Evaluierungsjob zu starten:
```
hyperpod start-job -n kubeflow \
--recipe evaluation/nova/nova_2_0/nova_lite/nova_lite_2_0_p5_48xl_gpu_bring_your_own_dataset_eval \
--override-parameters '{
"instance_type": "p5.48xlarge",
"container": "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-HP-Eval-latest",
"recipes.run.name": "",
"recipes.run.model_name_or_path": "",
"recipes.run.output_s3_path": "s3:///eval-results/",
"recipes.run.data_s3_path": "s3:///eval-data.jsonl"
}'
```
**Beschreibungen der Parameter**:
+ `recipes.run.name`: Eindeutiger Name für Ihren Bewertungsjob
+ `recipes.run.model_name_or_path`: Amazon S3 S3-URI von `manifest.json` oder Basismodellpfad (z. B.`nova-micro/prod`)
+ `recipes.run.output_s3_path`: Amazon S3 S3-Standort für Evaluierungsergebnisse
+ `recipes.run.data_s3_path`: Amazon S3 S3-Speicherort Ihres Bewertungsdatensatzes
**Tipps**:
+ **Modellspezifische Rezepte**: Für jede Modellgröße (Micro, Lite, Pro) gibt es ein eigenes Bewertungsrezept
+ **Bewertung des Basismodells**: Verwenden Sie Basismodellpfade (z. B.`nova-micro/prod`) anstelle von Checkpoints, um Basismodelle URIs zu bewerten
**Datenformat für die Evaluierung**
**Eingabeformat (JSONL**):
```
{
"metadata": "{key:4, category:'apple'}",
"system": "arithmetic-patterns, please answer the following with no other words: ",
"query": "What is the next number in this series? 1, 2, 4, 8, 16, ?",
"response": "32"
}
```
**Ausgabeformat**:
```
{
"prompt": "[{'role': 'system', 'content': 'arithmetic-patterns, please answer the following with no other words: '}, {'role': 'user', 'content': 'What is the next number in this series? 1, 2, 4, 8, 16, ?'}]",
"inference": "['32']",
"gold": "32",
"metadata": "{key:4, category:'apple'}"
}
```
**Feldbeschreibungen**:
+ `prompt`: Formatierte Eingabe, die an das Modell gesendet wurde
+ `inference`: Die generierte Antwort des Modells
+ `gold`: Richtige Antwort aus dem Eingabedatensatz erwartet
+ `metadata`: Optionale Metadaten, die von der Eingabe übergeben wurden
## Häufige Probleme
+ `ModuleNotFoundError: No module named 'nemo_launcher'`, je nachdem, wo es installiert `hyperpod_cli` ist`nemo_launcher`, müssen Sie möglicherweise zu Ihrem Python-Pfad etwas hinzufügen. Beispielbefehl:
```
export PYTHONPATH=/sagemaker-hyperpod-cli/src/hyperpod_cli/sagemaker_hyperpod_recipes/launcher/nemo/nemo_framework_launcher/launcher_scripts:$PYTHONPATH
```
+ `FileNotFoundError: [Errno 2] No such file or directory: '/tmp/hyperpod_current_context.json'`weist darauf hin, dass Sie den Befehl hyperpod connect cluster nicht ausgeführt haben.
+ Wenn Ihr Job nicht geplant ist, überprüfen Sie noch einmal, ob die Ausgabe Ihrer SageMaker HyperPod CLI diesen Abschnitt mit Jobnamen und anderen Metadaten enthält. Wenn nicht, installieren Sie helm chart erneut, indem Sie Folgendes ausführen:
```
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
rm -f ./get_helm.sh
```
# Zugang und Einrichtung von Nova Forge für
Um Amazon Nova Forge für die Verwendung mit Jobs einzurichten, müssen Sie:
+ Abonnieren Sie Amazon Nova Forge
+ Richten Sie einen Cluster ein
**Topics**
+ [Abonnieren Sie Amazon Nova Forge](nova-forge-subscribing.md)
+ [Infrastruktur einrichten](nova-forge-hyperpod-setup.md)
+ [Verantwortungsvolle KI](nova-forge-responsible-ai.md)
# Abonnieren Sie Amazon Nova Forge
Gehen Sie wie folgt vor, um auf die Funktionen von Amazon Nova Forge zuzugreifen:
1. Überprüfen Sie den Administratorzugriff auf das AWS Konto.
1. Navigieren Sie zur SageMaker KI-Konsole und [fordern Sie Zugriff auf Amazon Nova Forge](nova-forge.md) an.
1. Warten Sie, bis das Amazon Nova-Team eine Bestätigung per E-Mail erhalten hat, nachdem die Abonnementanfrage genehmigt wurde.
1. Kennzeichnen Sie Ihre Ausführungsrolle mit dem `forge-subscription` Tag. Dieses Tag ist für den Zugriff auf Funktionen und Checkpoints von Amazon Nova Forge erforderlich. Fügen Sie Ihrer Ausführungsrolle das folgende Tag hinzu:
+ Schlüssel: `forge-subscription`
+ Wert: `true`
**Anmerkung**
Die Standardfunktionen von Amazon Nova bleiben auch ohne ein Forge-Abonnement verfügbar. Amazon Nova Forge wurde für die Erstellung maßgeschneiderter Frontier-Modelle mit Kontrolle und Flexibilität in allen Modelltrainingsphasen entwickelt.
# Infrastruktur einrichten
Sobald Ihr Amazon Nova Forge-Abonnement genehmigt wurde, richten Sie die erforderliche Infrastruktur ein, um Forge-fähige Funktionen nutzen zu können. Ausführliche Anweisungen zur Erstellung eines EKS-Clusters mit einer eingeschränkten Instanzgruppe (RIG) finden Sie in den [Workshop-Anweisungen](https://catalog.us-east-1.prod.workshops.aws/workshops/dcac6f7a-3c61-4978-8344-7535526bf743/en-US).
# Verantwortungsvolle KI
**Einstellungen für die Inhaltsmoderation**: Kunden von Amazon Nova Forge haben Zugriff auf anpassbare Inhaltsmoderationseinstellungen (CCMS) für die Modelle Amazon Nova Lite 1.0 und Pro 1.0. CCMS ermöglicht es Ihnen, die Steuerung der Inhaltsmoderation an Ihre spezifischen Geschäftsanforderungen anzupassen und gleichzeitig wichtige verantwortungsvolle KI-Sicherheitsvorkehrungen zu treffen. Um festzustellen, ob Ihr geschäftlicher Anwendungsfall für CCMS in Frage kommt, wenden Sie sich an Ihren Amazon Web Services Services-Kundenbetreuer.
Amazon Nova Forge bietet ein Toolkit für verantwortungsvolle KI, das Trainingsdaten, Bewertungsbenchmarks und Laufzeitkontrollen umfasst, damit Sie Ihre Modelle an den Richtlinien für verantwortungsvolle KI von Amazon Nova ausrichten können.
**Trainingsdaten**: Die Kategorie „RAI“ bei der Datenmischung umfasst Fälle und Szenarien, in denen verantwortungsvolle KI-Prinzipien, Sicherheitsüberlegungen und verantwortungsvoller Technologieeinsatz im Vordergrund stehen. Nutzen Sie diese Informationen, um Ihre Modelle während der weiteren Vorschulung verantwortungsbewusst aufeinander abzustimmen.
**Bewertungen**: Es stehen Benchmark-Aufgaben zur Verfügung, mit denen Sie die Fähigkeit Ihres Modells testen können, unangemessene, schädliche oder falsche Inhalte zu erkennen und abzulehnen. Verwenden Sie diese Bewertungen, um den Unterschied zwischen der Leistung des Basismodells und der Leistung Ihres benutzerdefinierten Modells zu messen.
# Schulung für Amazon Nova-Modelle
Das Training von Amazon Nova-Modellen auf SageMaker HyperPod unterstützt mehrere Techniken, darunter Continued Pre-Training (CPT), Supervised Fine-Tuning (SFT) und Reinforcement Fine-Tuning (RFT). Jede Technik erfüllt unterschiedliche Anpassungsanforderungen und kann auf verschiedene Amazon Nova-Modellversionen angewendet werden.
**Topics**
+ [Fortgesetztes Vortraining (CPT)](nova-cpt.md)
+ [Überwachte Optimierung (SFT)](nova-fine-tune.md)
+ [Reinforcement Fine-Tuning (RFT) aktiviert SageMaker HyperPod](nova-hp-rft.md)
# Fortgesetztes Vortraining (CPT)
Continued Pre-Training (CPT) ist eine Trainingstechnik, die die Vortrainingsphase eines Basismodells verlängert, indem es mit zusätzlichem unbeschriftetem Text aus bestimmten Bereichen oder Korpora vertraut gemacht wird. Im Gegensatz zur überwachten Feinabstimmung, für die beschriftete Input-Output-Paare erforderlich sind, trainiert CPT anhand von Rohdokumenten, um dem Modell zu helfen, sich tiefere Kenntnisse über neue Bereiche anzueignen, domänenspezifische Terminologie und Schreibmuster zu erlernen und sich an bestimmte Inhaltstypen oder Fachbereiche anzupassen.
Dieser Ansatz ist besonders nützlich, wenn Sie über große Mengen (zig Milliarden Tokens) domänenspezifischer Textdaten verfügen, wie z. B. Rechtsdokumente, medizinische Literatur, technische Dokumentation oder firmeneigene Geschäftsinhalte, und Sie möchten, dass das Modell in diesem Bereich systemeigene Sprachkenntnisse entwickelt. Im Allgemeinen muss das Modell nach der CPT-Phase weitere Stufen zur Anpassung der Anweisungen durchlaufen, damit das Modell das neu gewonnene Wissen nutzen und nützliche Aufgaben ausführen kann.
**Unterstützte Modelle**
CPT ist für die folgenden Amazon Nova-Modelle verfügbar:
+ Nova 1.0 (Micro, Lite, Pro)
+ Nova 2.0 (Lite)
**Wann sollte Nova 1.0 im Vergleich zu Nova 2.0 verwendet werden**
Die Amazon Nova-Modellfamilie bietet mehrere Preis-Leistungs-Betriebspunkte, um ein optimales Verhältnis zwischen Genauigkeit, Geschwindigkeit und Kosten zu erzielen.
Wählen Sie Nova 2.0, wenn Sie Folgendes benötigen:
+ Fortgeschrittene Argumentationsfähigkeiten für komplexe analytische Aufgaben
+ Überragende Leistung in den Bereichen Programmieren, Mathematik und wissenschaftliche Problemlösung
+ Unterstützung für längere Kontextlängen
+ Bessere mehrsprachige Leistung
**Anmerkung**
Das größere Modell ist nicht immer besser. Berücksichtigen Sie bei der Auswahl zwischen den Modellen Nova 1.0 und Nova 2.0 den Kosten-Nutzen-Kompromiss und Ihre spezifischen Geschäftsanforderungen.
# CPT auf Nova 2.0
Amazon Nova Lite 2.0 ist ein Argumentationsmodell, das auf größeren und vielfältigeren Datensätzen als Nova Lite 1.0 trainiert wurde. Obwohl es sich um ein größeres Modell handelt, bietet Nova Lite 2.0 schnellere Schlussfolgerungen als Nova Lite 1.0 und bietet gleichzeitig erweiterte Argumentationsfähigkeiten, längere Kontextlängen und eine verbesserte Leistung bei Mehrsprachigkeit.
CPT auf Nova 2.0 ermöglicht es Ihnen, diese erweiterten Funktionen mit Ihren domänenspezifischen Daten zu erweitern, sodass das Modell fundierte Fachkenntnisse in Spezialgebieten entwickeln und gleichzeitig seine überlegenen Argumentations- und Analysefähigkeiten beibehalten kann.
## Beispiel für ein CPT-Rezept
Im Folgenden finden Sie ein Beispielrezept für CPT. Sie finden dieses und andere [Rezepte](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/training/nova) im Rezepte-Repository.
```
# Note:
# This recipe can run on p5.48xlarge
# Run config
run:
name: "my-cpt-run" # A descriptive name for your training job
model_type: "amazon.nova-2-lite-v1:0:256k" # Model variant specification, do not change
model_name_or_path: "nova-lite-2/prod" # Base model path, do not change
replicas: 8 # Number of compute instances for training, allowed values are 4, 8, 16, 32
data_s3_path: "" # Customer data paths
validation_data_s3_path: "" # Customer validation data paths
output_s3_path: "" # Output artifact path, job-specific configuration - not compatible with standard SageMaker Training Jobs
mlflow_tracking_uri: "" # Required for MLFlow
mlflow_experiment_name: "my-cpt-experiment" # Optional for MLFlow. Note: leave this field non-empty
mlflow_run_name: "my-cpt-run" # Optional for MLFlow. Note: leave this field non-empty
## Training specific configs
training_config:
task_type: cpt
max_length: 8192 # Maximum context window size (tokens)
global_batch_size: 256 # Global batch size, allowed values are 32, 64, 128, 256.
trainer:
max_steps: 10 # The number of training steps to run total
val_check_interval: 10 # The number of steps between running validation. Integer count or float percentage
limit_val_batches: 2 # Batches of the validation set to use each trigger
model:
hidden_dropout: 0.0 # Dropout for hidden states, must be between 0.0 and 1.0
attention_dropout: 0.0 # Dropout for attention weights, must be between 0.0 and 1.0
optim:
optimizer: adam
lr: 1e-5 # Learning rate
name: distributed_fused_adam # Optimizer algorithm, do not change
adam_w_mode: true # Enable AdamW mode
eps: 1e-06 # Epsilon for numerical stability
weight_decay: 0.0 # L2 regularization strength, must be between 0.0 and 1.0
adam_beta1: 0.9 # Beta1 for Adam optimizer
adam_beta2: 0.95 # Beta2 for Adam optimizer
sched:
warmup_steps: 10 # Learning rate warmup steps
constant_steps: 0 # Steps at constant learning rate
min_lr: 1e-6 # Minimum learning rate, must be lower than lr
```
## Datenaufbereitung für CPT auf 2.0
**Datenformatanforderungen**
Bei den Trainings- und Validierungsdatensätzen muss es sich um JSONL-Dateien im unten angegebenen Format handeln, wobei jede Zeile ein JSON-Objekt enthält, das eine Konversation mit den erforderlichen Feldern und der erforderlichen Struktur darstellt. Ein Beispiel:
```
{"text": "AWS stands for Amazon Web Services"}
{"text": "Amazon SageMaker is a fully managed machine learning service"}
{"text": "Amazon Bedrock is a fully managed service for foundation models"}
```
Texteinträge sollten natürlich fließende, qualitativ hochwertige Inhalte enthalten, die die Zieldomäne repräsentieren.
Testen Sie, ob die Daten in das [Arrow-Format](https://huggingface.co/docs/datasets/en/about_arrow) konvertiert werden können. Verwenden Sie das folgende Python-Skript, um Ihnen dabei zu helfen. Stellen Sie sicher, dass mindestens die `datasets==2.18.0` Version verwendet wird:
```
from datasets import load_dataset, load_from_disk
from pathlib import Path
input_path = Path("")
output_path = Path("")
dataset = load_dataset("json", data_files=str(input_path), split="train")
dataset.save_to_disk(str(output_path), max_shard_size="1GB")
try:
test_dataset = datasets.load_from_disk(output_dir)
print(f"Dataset loaded successfully ✅! Contains {len(test_dataset)} samples")
except Exception as e:
print(e)
```
Es sollte dieselbe Anzahl von Zeilen drucken wie in der JSONL-Datei.
Wenn Sie Datamixing verwenden, führen Sie den ersten Job mit aus. `max_steps=2` Dies hilft dabei, Optimierungen im Cluster für den Datenzugriff vorzunehmen und zu überprüfen, ob alle Datamixe verfügbar sind.
**Wie bereitet man Daten für CPT vor**
Trainingsdaten sind der wichtigste entscheidende Faktor für den Erfolg eines kontinuierlichen Vortrainings. CPT-Daten werden zwar oft als „unbeschriftet“ beschrieben, die Realität ist jedoch weitaus nuancierter. Wie Daten strukturiert, formatiert und präsentiert werden, bestimmt, ob das Modell die für den Geschäftsanwendungsfall erforderlichen Kenntnisse und Fähigkeiten vermittelt.
### Vorbereitung strukturierter Geschäftsdatensätze für CPT
Dies ist eine häufige Herausforderung für Unternehmen und Organisationen, die auf ihren Bereich spezialisierte Basismodelle entwickeln. Die meisten Unternehmen verfügen über umfangreiche Repositorien strukturierter Daten: Produktkataloge, Benutzerprofile, Transaktionsprotokolle, Formulareinreichungen, API-Aufrufe und Betriebsmetadaten. Auf den ersten Blick sieht dieser Text ganz anders aus als der unstrukturierte Webtext, der normalerweise in Standardvorschulungen verwendet wird.
Um effektiv aus strukturierten Geschäftsdaten zu lernen, sollten Sie sorgfältig über nachgelagerte Aufgaben nachdenken und die Datendarstellung so gestalten, dass das Modell die richtigen prädiktiven Beziehungen lernt.
Um das volle Potenzial kontinuierlicher Vorschulungen auszuschöpfen, sollten Sie Folgendes in Betracht ziehen:
+ Welche Aufgaben sollte das Modell zur Zeit der Inferenz erfüllen
+ Welche Informationen sind in den Rohdaten enthalten
+ Wie strukturiert man diese Daten, damit das Modell lernt, die Informationen korrekt zu extrahieren und zu bearbeiten
Strukturierte Daten einfach in das Training zu übertragen, bringt dem Modell nicht bei, darüber nachzudenken. Gestalten Sie die Datendarstellung aktiv so, dass das Modell daraus lernt.
In den folgenden Abschnitten finden Sie eine Literaturübersicht, die die Bedeutung der Datenerweiterung aufzeigt, und es werden Beispiele für Strategien zur Erweiterung strukturierter Geschäftsdaten vorgestellt, die nützliche Anregungen zur Behandlung und Organisation von Unternehmensdatensätzen für CPT geben.
**Strukturierte Daten für CPT in der Literatur**
CPT kann zwar Domänenfakten in das Modell packen, schafft es jedoch häufig nicht, diese Fakten abrufbar und manipulierbar zu machen, wenn sich Eingaben oder Aufgaben verschieben. Kontrollierte Experimente zeigen, dass sich Modelle ohne vielfältige Erweiterung während des Vortrainings Fakten auf spröde Weise merken, die auch nach einer späteren Anpassung der Anweisungen schwer zu extrahieren sind, und sie empfehlen, instruktionsähnliche Signale zu Beginn des Trainings zu injizieren. Bei halbstrukturierten Daten reduzieren randomisierte Serialisierung und andere Erweiterungen die Überanpassung von Schemas. Aus diesem Grund sollte CPT mit Aufgaben im Befehlsstil verschachtelt werden, anstatt zuerst ausgeführt und dann IFT. Untersuchungen, die sich auf das Finanzwesen konzentrieren, haben außerdem ergeben, dass das gemeinsame Mischen von CPT- und Befehlsdaten während der Batchzeit die Generalisierung verbessert und das Vergessen im Vergleich zur sequentiellen Rezeptur reduziert. Der technische Bericht von Qwen folgt demselben Muster, indem hochwertige Unterrichtsdaten in die Vorschulung selbst integriert werden, wodurch das Lernen im Kontext gefördert wird und die Einhaltung der Anweisungen erhalten bleibt, während gleichzeitig neues Fachwissen erworben wird.
Die Erweiterung der Daten für halbstrukturierte Korpora ist ein wichtiger Hebel. CPT, das synthetische Graphen berücksichtigt, erweitert kleine Domänensätze zu Entitätsverknüpften Korpora, die explizit Beziehungen und Verbindungen vermitteln, wobei der Abruf zum Zeitpunkt der Inferenz erfolgt. Gemeinsames CPT in Kombination mit Instruktionsmischung übertrifft sequentielle Pipelines im Finanzwesen und die Bilanzierung allgemeiner Daten verringert den Abbau allgemeiner Fähigkeiten. CPT in sehr großem Maßstab kann auch weiterhin breit gefächerte Fähigkeiten beibehalten und sogar Kompromisse durch die Zusammenführung von Modellen ermöglichen, weist aber dennoch darauf hin, dass die Anpassung der Lehrpläne ein wesentlicher nächster Schritt ist, wodurch der Wert der Einführung von Unterrichtssignalen während der CPT verstärkt wird.
**Schaffung von Diversität durch Randomisierung und Mischen**
Eine allgemeine Strategie, die hilft, anhand strukturierter und halbstrukturierter Datensätze effektiv Modelle zu vermitteln, besteht darin, die Reihenfolge der Felder in den Datensätzen zu mischen und einige Schlüssel sogar nach dem Zufallsprinzip wegzulassen.
Das Mischen der Felder zwingt das Modell dazu, zu lesen, was jeder Wert bedeutet, anstatt zu wissen, wo er erscheint, und die Beziehungen zwischen allen Feldern zu lernen. Wenn beispielsweise bei einem Videospiel, das im Amazon Store veröffentlicht wird, „Titel“, „Plattform“, „Preis“, „Zustand“ und „Ausgabe“ in unterschiedlichen Permutationen erscheinen, kann sich das Modell nicht auf „der dritte Slot ist Plattform“ verlassen. Es muss Labels an Werte binden und die bilateralen Beziehungen zwischen den Attributen lernen: Titel ⇄ Plattform, Plattform ⇄ Preis, Zustand ⇄ Preis. So kann es beispielsweise anhand eines Spielnamens und eines beobachteten Preises auf eine wahrscheinliche Plattform schließen oder eine plausible Preisspanne für einen Titel und eine Plattform abschätzen.
Das zufällige Ablegen von Schlüsseln während der Serialisierung wirkt wie ein Feature-Dropout: Es verhindert die Koadaption in einem Feld und zwingt das Modell, fehlende Informationen aus den verbleibenden Beweisen wiederherzustellen. Fehlt „Platform“, muss das Modell es aus der Titelzeichenfolge oder dem Kompatibilitätstext übernehmen. Wenn „Price“ ausgeblendet ist, muss es eine Triangulierung nach Plattform, Edition und Zustand vornehmen. Dies sorgt für Symmetrie (A→B und B→A), Stabilität gegenüber unübersichtlichen Auflistungen in der realen Welt und Schemainvarianz, wenn Felder fehlen, umbenannt oder neu angeordnet werden.
Ein Beispiel im Einkaufsstil macht es konkret. Serialisieren Sie denselben Artikel auf mehrere Arten — „Titel: 'Elden Ring' \$1 Plattform: PlayStation 5 \$1 Zustand: Gebraucht—Wie neu \$1 Preis: 34,99\$1“ und eine Permutation wie „Preis: 34,99\$1 \$1 Titel: 'Elden Ring' \$1 Zustand: Gebraucht—wie neu \$1 Plattform: 5“ — und bei einigen Durchgängen lassen Sie „Platform“ weg, während „Kompatibel mit“ in der Beschreibung belassen wird. PlayStation PS5 Trainiere ergänzende Ziele wie die Vorhersage der Plattform anhand von \$1title, price\$1 und die Vorhersage eines Preisbereichs anhand von \$1title, platform\$1. Da die Reihenfolge und sogar das Vorhandensein von Schlüsseln variieren, besteht die einzig stabile Strategie darin, die wahren Beziehungen zwischen Attributen zu lernen, anstatt sich eine Vorlage zu merken.
### Die Art und Weise, wie Daten präsentiert werden, ist wichtig
LLMs Lernen Sie, indem Sie anhand dessen, was sie bereits gesehen haben, das nächste Token vorhersagen. Die Reihenfolge der Felder und Ereignisse, die während des Trainings angezeigt werden, entscheidet also darüber, was das Modell lernen kann. Wenn das Trainingsformat mit der tatsächlichen Aufgabe übereinstimmt, wird der Verlust genau auf die Entscheidungstoken zurückgeführt. Werden Felder ohne Struktur zusammengewürfelt, lernt das Modell Abkürzungen oder merkt sich Beliebtheit und scheitert dann, wenn es aufgefordert wird, zwischen Optionen zu wählen.
Zeigen Sie zuerst die Situation, dann die Optionen und dann die Entscheidung. Wenn das Modell auch Informationen zu Ergebnissen oder Erklärungen erhalten soll, fügen Sie diese nach der Entscheidung ein.
### Proben für CPT verpacken
**Was ist Verpacken?**
Es bedeutet einfach, jedes Sequenzfenster in den Trainingsdaten mit mehreren ganzen Beispielen zu füllen, sodass das Fenster dicht mit echten Tokens und nicht mit Füllungen ist.
**Warum dies wichtig ist**
Während des Trainings wird eine maximale Kontextlänge festgelegt, zum Beispiel 8.192 Token. Stapel werden auf [Stapelgröße × Kontextlänge] geformt. Wenn ein Trainingsbeispiel kürzer als die Länge des Kontextes ist, werden die verbleibenden Positionen aufgefüllt. Auch wenn der Verlust maskiert wird, werden die Aufmerksamkeits- und MLP-Kernel immer noch mit dem Auffüllen gefüllt, sodass die Rechenleistung für Tokens, die kein Lernsignal enthalten, bezahlt wird.
**Wie packt man?**
Um mehrere Proben zu packen, verketten Sie mehrere Trainingsproben mit einem ` [DOC] ` Trennzeichen dazwischen (beachten Sie das Leerzeichen vor und nach dem [DOC]), sodass die gesamte Länge der Proben unter der gewünschten Kontextlänge liegt.
Ein Beispiel für ein gepacktes Dokument würde wie folgt aussehen:
```
{"text": "training sample 1 [DOC] training sample 2 [DOC] training sample 3"}
```
### CPT-Tuning-Parameter
Zu den Parametern, die für die Feinabstimmung mit CPT verfügbar sind, gehören:
**Ausführen der Konfiguration**
+ **Name**: Ein aussagekräftiger Name für Ihren Ausbildungsjob. Auf diese Weise können Sie Ihren Job in der AWS Management Console leichter identifizieren.
+ **model\$1type**: Die zu verwendende Amazon Nova-Modellvariante. Die verfügbaren Optionen sind. `amazon.nova-2-lite-v1:0:256k`
+ **model\$1name\$1or\$1path: Der Pfad zum** Basismodell, das Sie für Ihr Training verwenden möchten. Die verfügbaren Optionen sind`nova-lite-2/prod`, oder der S3-Pfad für den Checkpoint nach dem Training (). `s3://customer-escrow-bucket-unique_id/training_run_name`
+ **Replikate**: Die Anzahl der Recheninstanzen, die für verteilte Schulungen verwendet werden sollen. Die verfügbaren Werte variieren abhängig vom ausgewählten Modell. Amazon Nova Lite 2.0 unterstützt 4, 8, 16 oder 32 Replikate.
+ **data\$1s3\$1path**: Der S3-Speicherort des Trainingsdatensatzes, bei dem es sich um eine JSONL-Datei handelt. Diese Datei muss sich in demselben Konto und derselben Region wie AWS der Cluster befinden. Alle angegebenen S3-Standorte müssen sich im selben Konto und in derselben Region befinden.
+ **validation\$1data\$1s3\$1path: (Optional) Der S3-Speicherort** des Validierungsdatensatzes, bei dem es sich um eine JSONL-Datei handelt. Diese Datei muss sich im selben Konto und derselben Region wie der Cluster befinden. Alle angegebenen S3-Standorte müssen sich im selben Konto und in derselben Region befinden.
+ **output\$1s3\$1path: Der S3-Speicherort**, an dem das Manifest und die Protokolle gespeichert werden. TensorBoard Alle angegebenen S3-Standorte müssen sich im selben Konto und in derselben AWS Region befinden. AWS
+ **mlflow\$1tracking\$1uri**: Der ARN der App, der für die Protokollierung verwendet werden soll MLFlow MLFlow
+ ** MLFlow mlflow\$1experiment\$1name**: Name des Experiments
+ **mlflow\$1run\$1name**: MLFlow Laufname
**Konfiguration des Trainings**
+ **max\$1length**: Die maximale Sequenzlänge in Tokens. Dies bestimmt die Größe des Kontextfensters für das Training. Der maximal unterstützte Wert beträgt 8192 Token für CPT.
Längere Sequenzen verbessern die Trainingseffizienz auf Kosten eines erhöhten Speicherbedarfs. Wir empfehlen, dass Sie den Parameter max\$1length an Ihre Datenverteilung anpassen.
+ **global\$1batch\$1size**: Die Gesamtzahl der Trainingsproben, die zusammen in einem Vorwärts- oder Rückwärtsgang für alle Geräte und Mitarbeiter verarbeitet wurden.
Dieser Wert multipliziert die Batchgröße pro Gerät und die Anzahl der Geräte. Er wirkt sich auf die Stabilität des Trainings und den Durchsatz aus. Wir empfehlen Ihnen, mit einer Batchgröße zu beginnen, die problemlos in Ihren Arbeitsspeicher passt, und anschließend hochzuskalieren. Bei Domain-spezifischen Daten können größere Batches zu einer übermäßigen Gradientenglättung führen.
**Trainer-Einstellungen**
+ **max\$1steps**: Die Anzahl der auszuführenden Trainingsschritte. Jeder Schritt trainiert das Modell mit der `global_batch_size` Anzahl der Elemente
**Einstellungen des Modells**
+ **hidden\$1dropout**: Die Wahrscheinlichkeit, dass versteckte Statusausgaben gelöscht werden. Erhöhen Sie diesen Wert um etwa 0,0 bis 0,2, um eine Überanpassung bei kleineren Datensätzen zu vermeiden. Zulässig sind alle Werte zwischen 0 und 1, beide inklusive.
+ **attention\$1dropout**: Die Wahrscheinlichkeit, dass die Aufmerksamkeit verloren geht. Dieser Parameter kann bei der Generalisierung helfen. Zulässig sind alle Werte zwischen 0 und 1, beide inklusive.
**Konfiguration des Optimierers**
+ **lr**: Die Lernrate, die die Schrittgröße während der Optimierung steuert. Für eine gute Leistung empfehlen wir Werte zwischen 1e-6 und 1e-4. Zulässig sind alle Werte zwischen 0 und 1, beide inklusive.
+ **Name**: Der Optimierer-Algorithmus. Derzeit wird nur `distributed_fused_adam` unterstützt.
+ **weight\$1decay**: Die Stärke der L2-Regularisierung. Höhere Werte (zwischen 0,01 und 0,1) erhöhen die Regularisierung.
+ **warmup\$1steps: Die Anzahl der Schritte zur schrittweisen Erhöhung** der Lernrate. Dies verbessert die Trainingsstabilität. Zulässig sind alle Werte zwischen 1 und 20, beide inklusive.
+ **min\$1lr**: Die minimale Lernrate am Ende des Zerfalls. Gültige Werte liegen zwischen 0 und 1 (beide inklusive), müssen jedoch unter der Lernrate liegen.
# Überwachte Optimierung (SFT)
Der SFT-Trainingsprozess besteht aus zwei Hauptphasen:
+ **Datenvorbereitung**: Folgen Sie den festgelegten Richtlinien, um Datensätze zu erstellen, zu bereinigen oder neu zu formatieren, sodass sie die erforderliche Struktur erhalten. Stellen Sie sicher, dass Eingaben, Ausgaben und Zusatzinformationen (wie Argumentationsspuren oder Metadaten) richtig aufeinander abgestimmt und formatiert sind.
+ **Trainingskonfiguration**: Definieren Sie, wie das Modell trainiert werden soll. Bei der Verwendung wird diese Konfiguration in eine YAML-Rezeptdatei geschrieben, die Folgendes beinhaltet:
+ Datenquellenpfade (Trainings- und Validierungsdatensätze)
+ Wichtige Hyperparameter (Epochen, Lernrate, Batchgröße)
+ Optionale Komponenten (verteilte Trainingsparameter usw.)
## Vergleich und Auswahl von Nova-Modellen
Amazon Nova 2.0 ist ein Modell, das auf einem größeren und vielfältigeren Datensatz als Amazon Nova 1.0 trainiert wurde. Zu den Verbesserungen gehören:
+ **Verbesserte Argumentationsfähigkeiten** mit Unterstützung für den Modus „Explizites Denken“
+ **Umfassendere mehrsprachige Leistung** in weiteren Sprachen
+ **Verbesserte Leistung bei komplexen Aufgaben**, einschließlich Codierung und Verwendung von Tools
+ **Erweiterte Kontexthandhabung** mit besserer Genauigkeit und Stabilität bei längeren Kontextlängen
## Wann sollte Nova 1.0 im Vergleich zu Nova 2.0 verwendet werden
Wählen Sie Amazon Nova 2.0, wenn:
+ Überlegene Leistung mit fortgeschrittenen Argumentationsfähigkeiten ist erforderlich
+ Mehrsprachiger Support oder die Bearbeitung komplexer Aufgaben sind erforderlich
+ Bessere Ergebnisse beim Programmieren, beim Aufrufen von Tools oder bei analytischen Aufgaben sind erforderlich
# SFT auf Nova 2.0
Amazon Nova Lite 2.0 bietet erweiterte Funktionen für die überwachte Feinabstimmung, darunter einen erweiterten Argumentationsmodus, ein verbessertes multimodales Verständnis und eine erweiterte Kontexthandhabung. Mit SFT on Nova 2.0 können Sie diese leistungsstarken Funktionen an Ihre spezifischen Anwendungsfälle anpassen und gleichzeitig die überragende Leistung des Modells bei komplexen Aufgaben beibehalten.
Zu den wichtigsten Funktionen von SFT on Nova 2.0 gehören:
+ **Unterstützung des Argumentationsmodus**: Trainieren Sie Modelle so, dass sie vor den endgültigen Antworten explizite Argumentationsspuren erzeugen, um die Analysemöglichkeiten zu verbessern.
+ **Fortgeschrittenes multimodales Training**: Präzise Feinabstimmung in Sachen Dokumentenverständnis (PDF), Videoverständnis und bildgestützte Aufgaben.
+ **Funktionen zum Aufrufen von Tools**: Trainieren Sie Modelle, um externe Tools effektiv zu nutzen und Funktionen für komplexe Workflows aufzurufen.
+ **Erweiterte Kontextunterstützung**: Nutzen Sie längere Kontextfenster mit besserer Stabilität und Genauigkeit für dokumentenintensive Anwendungen.
**Anmerkung**
Weitere Informationen darüber, welche Container-Images oder Beispielrezepte verwendet werden sollten, finden Sie unter [Amazon Nova-Rezepte](nova-model-recipes.md).
**Topics**
+ [Auswahl des Argumentationsmodus (nur Nova 2.0)](#nova-sft-2-reasoning-mode)
+ [Datenformat für das Aufrufen des Tools](#nova-sft-2-tool-calling)
+ [Dokument, das das Datenformat versteht](#nova-sft-2-document-understanding)
+ [Video Understanding für SFT](#nova-sft-2-video-understanding)
+ [Anweisungen zum Hochladen von Daten](#nova-sft-2-data-upload)
+ [Einen Job zur Feinabstimmung erstellen](#nova-sft-2-creating-job)
+ [SFT-Tuning-Parameter](#nova-sft-2-tuning-parameters)
+ [Anleitung zu Hyperparametern](#nova-sft-2-hyperparameters)
## Beispiel für ein SFT-Rezept
Unten finden Sie ein Beispielrezept für SFT. Sie finden dieses und andere [Rezepte](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/fine-tuning/nova) im Rezepte-Repository.
```
run:
name: my-full-rank-sft-run
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod
data_s3_path: s3://my-bucket-name/train.jsonl # only and not compatible with SageMaker Training Jobs
replicas: 4 # Number of compute instances for training, allowed values are 4, 8, 16, 32
output_s3_path: s3://my-bucket-name/outputs/ # Output artifact path (HyperPod job-specific; not compatible with standard SageMaker Training Jobs)
mlflow_tracking_uri: "" # Required for MLFlow
mlflow_experiment_name: "my-full-rank-sft-experiment" # Optional for MLFlow. Note: leave this field non-empty
mlflow_run_name: "my-full-rank-sft-run" # Optional for MLFlow. Note: leave this field non-empty
training_config:
max_steps: 100 # Maximum training steps. Minimal is 4.
save_steps: ${oc.select:training_config.max_steps} # How many training steps the checkpoint will be saved
save_top_k: 5 # Keep top K best checkpoints. Note supported only for jobs. Minimal is 1.
max_length: 32768 # Sequence length (options: 8192, 16384, 32768 [default], 65536)
global_batch_size: 32 # Global batch size (options: 32, 64, 128)
reasoning_enabled: true # If data has reasoningContent, set to true; otherwise False
lr_scheduler:
warmup_steps: 15 # Learning rate warmup steps. Recommend 15% of max_steps
min_lr: 1e-6 # Minimum learning rate, must be between 0.0 and 1.0
optim_config: # Optimizer settings
lr: 1e-5 # Learning rate, must be between 0.0 and 1.0
weight_decay: 0.0 # L2 regularization strength, must be between 0.0 and 1.0
adam_beta1: 0.9 # Exponential decay rate for first-moment estimates
adam_beta2: 0.95 # Exponential decay rate for second-moment estimates
peft: # Parameter-efficient fine-tuning (LoRA)
peft_scheme: "null" # Disable LoRA for PEFT
```
## Auswahl des Argumentationsmodus (nur Nova 2.0)
Amazon Nova 2.0 unterstützt den Argumentationsmodus für erweiterte Analysefunktionen:
+ **Argumentationsmodus (aktiviert)**:
+ `reasoning_enabled: true`In der Trainingskonfiguration festgelegt
+ Modellieren Sie Übungen, um Argumentationsspuren vor den endgültigen Antworten zu generieren
+ Verbessert die Leistung bei komplexen Argumentationsaufgaben
+ **Modus ohne Argumentation (deaktiviert)**:
+ Den Parameter setzen `reasoning_enabled: false` oder weglassen (Standard)
+ Standard-SFT ohne explizite Begründung
+ Geeignet für Aufgaben, bei denen Argumentation nicht von Vorteil ist step-by-step
**Anmerkung**
Wenn Argumentation aktiviert ist, ist ein hoher Argumentationsaufwand erforderlich. Für SFT gibt es keine Option mit geringem Argumentationsaufwand.
Inhalte zum multimodalen Denken werden für SFT nicht unterstützt. Der Argumentationsmodus gilt für reine Texteingaben.
### Verwendung des Argumentationsmodus bei Datensätzen, bei denen es sich nicht um logische Überlegungen handelt
Das Training von Amazon Nova mit einem Datensatz ohne Argumentation `reasoning_enabled: true` ist zulässig. Dies kann jedoch dazu führen, dass das Modell seine Argumentationsfähigkeit verliert, da Amazon Nova in erster Linie lernt, die in den Daten enthaltenen Antworten zu generieren, ohne Argumentation anzuwenden.
Wenn Sie Amazon Nova mit einem Datensatz ohne Argumentation trainieren, aber dennoch Argumentation während der Inferenz verwenden möchten:
1. Deaktivieren Sie die Argumentation während des Trainings () `reasoning_enabled: false`
1. Aktiviere die Argumentation später während der Inferenz
Dieser Ansatz ermöglicht zwar eine Argumentation zum Zeitpunkt der Inferenz, garantiert jedoch keine bessere Leistung im Vergleich zu Schlussfolgerungen ohne Argumentation.
**Bewährte Methode:** Aktivieren Sie Argumentation sowohl für Training als auch für Folgerungen, wenn Sie Datensätze mit Argumentation verwenden, und deaktivieren Sie sie für beide, wenn Sie Datensätze verwenden, die keine Argumentation verwenden.
**Anmerkung**
Weitere Informationen darüber, welche Container-Images oder Beispielrezepte verwendet werden sollten, finden Sie unter [Amazon Nova-Rezepte](nova-model-recipes.md).
## Datenformat für das Aufrufen des Tools
SFT unterstützt Trainingsmodelle für die Verwendung von Tools (Funktionsaufruf). Im Folgenden finden Sie ein Beispiel für ein Eingabeformat für den Aufruf von Tools:
**Beispiel für eine Eingabe:**
```
{
"schemaVersion": "bedrock-conversation-2024",
"system": [
{
"text": "You are an expert in composing function calls."
}
],
"toolConfig": {
"tools": [
{
"toolSpec": {
"name": "getItemCost",
"description": "Retrieve the cost of an item from the catalog",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"item_name": {
"type": "string",
"description": "The name of the item to retrieve cost for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to retrieve cost for"
}
},
"required": [
"item_id"
]
}
}
}
},
{
"toolSpec": {
"name": "getItemAvailability",
"description": "Retrieve whether an item is available in a given location",
"inputSchema": {
"json": {
"type": "object",
"properties": {
"zipcode": {
"type": "string",
"description": "The zipcode of the location to check in"
},
"quantity": {
"type": "integer",
"description": "The number of items to check availability for"
},
"item_id": {
"type": "string",
"description": "The ASIN of item to check availability for"
}
},
"required": [
"item_id", "zipcode"
]
}
}
}
}
]
},
"messages": [
{
"role": "user",
"content": [
{
"text": "I need to check whether there are twenty pieces of the following item available. Here is the item ASIN on Amazon: id-123. Please check for the zipcode 94086"
}
]
},
{
"role": "assistant",
"content": [
{
"reasoningContent": {
"reasoningText": {
"text": "The user wants to check how many pieces of the item with ASIN id-123 are available in the zipcode 94086"
}
}
},
{
"toolUse": {
"toolUseId": "getItemAvailability_0",
"name": "getItemAvailability",
"input": {
"zipcode": "94086",
"quantity": 20,
"item_id": "id-123"
}
}
}
]
},
{
"role": "user",
"content": [
{
"toolResult": {
"toolUseId": "getItemAvailability_0",
"content": [
{
"text": "[{\"name\": \"getItemAvailability\", \"results\": {\"availability\": true}}]"
}
]
}
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Yes, there are twenty pieces of item id-123 available at 94086. Would you like to place an order or know the total cost?"
}
]
}
]
}
```
Wichtige Überlegungen zum Aufrufen von Tool-Daten:
+ ToolUse darf nur in der Runde des Assistenten erscheinen
+ ToolResult darf nur in der Runde eines Benutzers erscheinen
+ ToolResult sollte nur Text oder JSON sein; andere Modalitäten werden derzeit für Amazon Nova-Modelle nicht unterstützt
+ Das InputSchema in der ToolSpec muss ein gültiges JSON-Schema-Objekt sein
+ Jeder Assistent ToolResult muss auf einen gültigen Wert toolUseId aus einem vorherigen Assistenten verweisen ToolUse, wobei jeder Assistent genau einmal pro toolUseId Konversation verwendet wird
**Anmerkung**
Weitere Informationen darüber, welche Container-Images oder Beispielrezepte verwendet werden sollten, finden Sie unter [Amazon Nova-Rezepte](nova-model-recipes.md).
## Dokument, das das Datenformat versteht
SFT unterstützt Trainingsmodelle für Aufgaben zum Verständnis von Dokumenten. Im Folgenden finden Sie ein Beispiel für ein Eingabeformat:
**Beispiel für eine Eingabe**
```
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"document": {
"format": "pdf",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/documents/customer_service_debugging.pdf",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
],
"reasoning_content": [
{
"text": "I need to find the relevant section in the document to answer the question.",
"type": "text"
}
]
}
]
}
```
Wichtige Überlegungen zum Verständnis von Dokumenten:
+ Es werden nur PDF-Dateien unterstützt
+ Die maximale Dokumentgröße beträgt 10 MB
+ Ein Beispiel kann Dokumente und Text enthalten, darf jedoch keine Kombination von Dokumenten mit anderen Modalitäten (wie Bildern oder Videos) enthalten
**Anmerkung**
Weitere Informationen darüber, welche Container-Images oder Beispielrezepte verwendet werden sollten, finden Sie unter [Amazon Nova-Rezepte](nova-model-recipes.md).
## Video Understanding für SFT
SFT unterstützt die Feinabstimmung von Modellen für Videoverständnisaufgaben. Im Folgenden finden Sie ein Beispiel für ein Eingabeformat:
**Beispiel für eine Eingabe**
```
{
"schemaVersion": "bedrock-conversation-2024",
"messages": [
{
"role": "user",
"content": [
{
"text": "What are the ways in which a customer can experience issues during checkout on Amazon?"
},
{
"video": {
"format": "mp4",
"source": {
"s3Location": {
"uri": "s3://my-bucket-name/path/to/videos/customer_service_debugging.mp4",
"bucketOwner": "123456789012"
}
}
}
}
]
},
{
"role": "assistant",
"content": [
{
"text": "Customers can experience issues with 1. Data entry, 2. Payment methods, 3. Connectivity while placing the order. Which one would you like to dive into?"
}
],
"reasoning_content": [
{
"text": "I need to find the relevant section in the video to answer the question.",
"type": "text"
}
]
}
]
}
```
Wichtige Überlegungen zum Verständnis von Videos:
+ Videos können maximal 50 MB groß sein
+ Videos können bis zu 15 Minuten lang sein
+ Pro Beispiel ist nur ein Video zulässig. Mehrere Videos in derselben Stichprobe werden nicht unterstützt
+ Ein Beispiel kann Video und Text enthalten, aber kein Video mit anderen Modalitäten (wie Bildern oder Dokumenten) mischen
**Anmerkung**
Weitere Informationen darüber, welche Container-Images oder Beispielrezepte verwendet werden sollten, finden Sie unter [Amazon Nova-Rezepte](nova-model-recipes.md).
## Anweisungen zum Hochladen von Daten
Laden Sie Trainings- und Validierungsdatensätze in einen S3-Bucket hoch. Geben Sie diese Speicherorte im `run` Rezeptblock an:
```
## Run config
run:
...
data_s3_path: "s3:////.jsonl"
```
**Hinweis**: Ersetzen Sie``,``, ````, und `` durch tatsächliche S3-Pfade.
**Hinweis**: Validierungsdatensätze werden derzeit nicht für SFT mit Amazon Nova 2.0 unterstützt. Wenn ein Validierungsdatensatz bereitgestellt wird, wird dieser ignoriert.
## Einen Job zur Feinabstimmung erstellen
Definieren Sie das Basismodell mithilfe der `model_name_or_path` Felder `model_type` und im `run` Block:
```
## Run config
run:
...
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: nova-lite-2/prod
...
```
## SFT-Tuning-Parameter
Zu den Parametern, die für die Optimierung mit SFT verfügbar sind, gehören:
**Ausführen der Konfiguration**
+ **Name**: Ein aussagekräftiger Name für Ihren Ausbildungsjob. Auf diese Weise können Sie Ihren Job in der AWS Management Console leichter identifizieren.
+ **model\$1type**: Die zu verwendende Amazon Nova-Modellvariante. Die verfügbaren Optionen sind. `amazon.nova-2-lite-v1:0:256k`
+ **model\$1name\$1or\$1path: Der Pfad zum** Basismodell, das Sie für Ihr Training verwenden möchten. Die verfügbaren Optionen sind`nova-lite-2/prod`, oder der S3-Pfad für den Checkpoint nach dem Training (). `s3://customer-escrow-bucket-unique_id/training_run_name`
+ **Replikate**: Die Anzahl der Recheninstanzen, die für verteilte Schulungen verwendet werden sollen. Die verfügbaren Werte variieren abhängig vom ausgewählten Modell. Amazon Nova Lite 2.0 unterstützt 4, 8, 16 oder 32 Replikate.
+ **data\$1s3\$1path**: Der S3-Speicherort des Trainingsdatensatzes, bei dem es sich um eine JSONL-Datei handelt. Diese Datei muss sich in demselben Konto und derselben Region wie AWS der Cluster befinden. Alle angegebenen S3-Standorte müssen sich im selben Konto und in derselben Region befinden.
+ **validation\$1data\$1s3\$1path: (Optional) Der S3-Speicherort** des Validierungsdatensatzes, bei dem es sich um eine JSONL-Datei handelt. Diese Datei muss sich im selben Konto und derselben Region wie der Cluster befinden. Alle angegebenen S3-Standorte müssen sich im selben Konto und in derselben Region befinden.
+ **output\$1s3\$1path: Der S3-Speicherort**, an dem das Manifest und die Protokolle gespeichert werden. TensorBoard Alle angegebenen S3-Standorte müssen sich im selben Konto und in derselben AWS Region befinden. AWS
+ **mlflow\$1tracking\$1uri**: Der ARN der App, der für die Protokollierung verwendet werden soll. MLFlow MLFlow
+ ** MLFlow mlflow\$1experiment\$1name**: Name des Experiments.
+ **mlflow\$1run\$1name: Name der Ausführung.** MLFlow
**Konfiguration des Trainings**
+ **max\$1steps**: Die Anzahl der auszuführenden Trainingsschritte. In jedem Schritt wird das Modell anhand der `global_batch_size` Anzahl der Elemente trainiert.
+ **save\$1steps**: Die Häufigkeit (in Schritten), mit der Modell-Checkpoints während des Trainings gespeichert werden.
+ **save\$1top\$1k**: Die maximale Anzahl der besten Checkpoints, die auf Grundlage von Validierungsmetriken beibehalten werden sollen.
+ **max\$1length: Die maximale Sequenzlänge** in Token. Dies bestimmt die Größe des Kontextfensters für das Training. Der maximal unterstützte Wert beträgt 32768 Token für SFT.
Längere Sequenzen verbessern die Trainingseffizienz auf Kosten eines erhöhten Speicherbedarfs. Wir empfehlen, dass Sie den Parameter max\$1length an Ihre Datenverteilung anpassen.
+ **global\$1batch\$1size**: Die Gesamtzahl der Trainingsproben, die zusammen in einem Vorwärts- oder Rückwärtsgang für alle Geräte und Mitarbeiter verarbeitet wurden.
Dieser Wert multipliziert die Batchgröße pro Gerät und die Anzahl der Geräte. Er wirkt sich auf die Stabilität des Trainings und den Durchsatz aus. Wir empfehlen Ihnen, mit einer Batchgröße zu beginnen, die problemlos in Ihren Arbeitsspeicher passt, und anschließend hochzuskalieren. Bei Domain-spezifischen Daten können größere Batches zu einer übermäßigen Gradientenglättung führen.
+ **reasoning\$1enabled**: Boolesches Kennzeichen zur Aktivierung von Argumentationsfähigkeiten während des Trainings.
**Ratenplaner für Lernprogramme**
+ **warmup\$1steps: Die Anzahl der Schritte zur** schrittweisen Erhöhung der Lernrate. Dies verbessert die Trainingsstabilität.
+ **min\$1lr**: Die minimale Lernrate am Ende des Zerfalls. Gültige Werte liegen zwischen 0 und 1 (beide inklusive), müssen jedoch unter der Lernrate liegen.
**Konfiguration des Optimierers**
+ **lr**: Die Lernrate, die die Schrittgröße während der Optimierung steuert. Für eine gute Leistung empfehlen wir Werte zwischen 1e-6 und 1e-4. Zulässig sind alle Werte zwischen 0 und 1, beide inklusive.
+ **weight\$1decay**: Die Stärke der L2-Regularisierung. Höhere Werte (zwischen 0,01 und 0,1) erhöhen die Regularisierung.
+ **adam\$1beta1**: Die exponentielle Zerfallsrate für Schätzungen des ersten Moments im Adam-Optimizer. Die Standardeinstellung ist 0,9.
+ **adam\$1beta2**: Die exponentielle Zerfallsrate für Schätzungen des zweiten Moments im Adam-Optimizer. Die Standardeinstellung ist 0,95.
**PEFT-Konfiguration**
+ **peft\$1scheme: Das** zu verwendende parametereffiziente Feinabstimmungsschema. Die Optionen stehen für die Feinabstimmung mit vollem Rang oder `'null'` für die Feinabstimmung auf LoRa-Basis zur Verfügung. `lora`
**LoRa-Tuning (wenn peft\$1scheme 'lora' ist)**
+ **alpha**: Der LoRa-Skalierungsparameter. Steuert das Ausmaß der Low-Rank-Anpassung. Typische Werte liegen im Bereich von 8 bis 128.
+ **lora\$1plus\$1lr\$1ratio: Das Lernratenverhältnis** für die LoRa\$1-Optimierung. Dieser Multiplikator passt die Lernrate speziell für LoRa-Parameter an.
## Anleitung zu Hyperparametern
Verwenden Sie je nach Trainingsansatz die folgenden empfohlenen Hyperparameter:
**Training mit vollem Rang**
+ **Epochen**: 1
+ **Lernrate (lr): 1e-5**
+ **Minimale Lernrate (min\$1lr**): 1e-6
**LoRa (Low-Rank-Anpassung)**
+ **Epochen**: 2
+ **Lernrate (lr): 5e-5**
+ **Minimale Lernrate (min\$1lr**): 1e-6
**Hinweis**: Passen Sie diese Werte je nach Datensatzgröße und Validierungsleistung an. Überwachen Sie die Trainingsmetriken, um eine Überanpassung zu vermeiden.
# Reinforcement Fine-Tuning (RFT) aktiviert SageMaker HyperPod
Reinforcement Fine-Tuning (RFT) ist eine Technik des maschinellen Lernens, die die Modellleistung durch Feedbacksignale — messbare Werte oder Belohnungen, die auf die Qualität der Antworten hinweisen — verbessert, anstatt durch direkte Überwachung mit exakt richtigen Antworten. Im Gegensatz zur herkömmlichen überwachten Feinabstimmung, die aus Input-Output-Paaren lernt, verwendet RFT Belohnungsfunktionen, um Modellantworten zu bewerten, und optimiert das Modell iterativ, um diese Belohnungen zu maximieren.
Dieser Ansatz ist besonders effektiv für Aufgaben, bei denen es schwierig ist, die exakte korrekte Ausgabe zu definieren, Sie aber die Qualität der Antworten zuverlässig messen können. RFT ermöglicht es Modellen, komplexe Verhaltensweisen und Präferenzen durch Versuche und Feedback zu erlernen, und eignet sich daher ideal für Anwendungen, die eine nuancierte Entscheidungsfindung, kreative Problemlösung oder die Einhaltung bestimmter Qualitätskriterien erfordern, die programmatisch bewertet werden können.
**Wann sollte RFT verwendet werden**
Verwenden Sie RFT, wenn Sie klare, messbare Erfolgskriterien definieren können, aber Schwierigkeiten haben, exakt korrekte Ergebnisse für das Training zu liefern. Es ist ideal für Aufgaben, bei denen die Qualität subjektiv oder facettenreich ist — wie kreatives Schreiben, Codeoptimierung oder komplexes Denken —, bei denen es mehrere gültige Lösungen gibt, von denen jedoch einige eindeutig besser sind als andere.
RFT funktioniert am besten, wenn Sie über Folgendes verfügen:
+ Eine zuverlässige Belohnungsfunktion, die Modellausgaben programmgesteuert auswerten kann
+ Sie müssen das Modellverhalten an bestimmten Präferenzen oder Einschränkungen ausrichten
+ Situationen, in denen die herkömmliche überwachte Feinabstimmung unzureichend ist, weil es teuer oder unpraktisch ist, hochwertige, beschriftete Beispiele zu sammeln
Ziehen Sie RFT für Anwendungen in Betracht, die iterative Verbesserungen, Personalisierung oder die Einhaltung komplexer Geschäftsregeln erfordern, die als Belohnungssignale kodiert werden können.
**Wofür ist RFT am besten geeignet**
RFT zeichnet sich in Bereichen aus, in denen die Ausgabequalität objektiv gemessen werden kann, es jedoch schwierig ist, optimale Antworten im Voraus zu definieren:
+ **Mathematische Problemlösung: Überprüfbare Richtigkeit mit mehreren Lösungswegen**
+ **Codegenerierung und -optimierung**: Testbare Ausführungsergebnisse und Leistungskennzahlen
+ **Aufgaben zum wissenschaftlichen Denken**: Logische Konsistenz und sachliche Richtigkeit
+ **Strukturierte Datenanalyse**: Programmatisch überprüfbare Ergebnisse
+ **Mehrstufiges Denken: Aufgaben**, die eine logische Weiterentwicklung erfordern step-by-step
+ **Toolnutzung und API-Aufrufe**: Der Erfolg ist an den Ausführungsergebnissen messbar
+ **Komplexe Arbeitsabläufe**: Einhaltung bestimmter Einschränkungen und Geschäftsregeln
RFT funktioniert hervorragend, wenn Sie mehrere konkurrierende Ziele wie Genauigkeit, Effizienz und Stil in Einklang bringen müssen.
**Wann sollte der Argumentationsmodus für das RFT-Training verwendet werden**
Amazon Nova 2.0 unterstützt den Argumentationsmodus während des RFT-Trainings. Die folgenden Modi sind verfügbar:
+ **none: Keine** Begründung (lassen Sie das Feld reasoning\$1effort weg)
+ **niedrig: Minimaler Argumentationsaufwand**
+ **hoch**: Maximales Argumentationsvermögen (Standard, wenn reasoning\$1effort angegeben ist)
**Anmerkung**
Es gibt keine mittlere Option für RFT. Wenn das Feld reasoning\$1effort in Ihrer Konfiguration nicht vorhanden ist, ist Reasoning deaktiviert.
Verwenden Sie High Reasoning für Folgendes:
+ Komplexe analytische Aufgaben
+ Mathematische Problemlösung
+ Mehrstufige logische Deduktion
+ Aufgaben, bei denen step-by-step Denken einen Mehrwert bietet
Verwenden Sie in folgenden Fällen keine Argumentation (lassen Sie Reasoning\$1Effort weg) oder wenig Argumentation:
+ Einfache sachliche Fragen
+ Direkte Klassifizierungen
+ Geschwindigkeits- und Kostenoptimierung
+ Unkomplizierte Beantwortung von Fragen
**Wichtig**
Höhere Argumentationsmodi erhöhen den Zeit- und Kostenaufwand für das Training, erhöhen die Inferenzlatenz und die Kosten, erhöhen aber auch die Leistungsfähigkeit des Modells für komplexe Denkaufgaben.
**Unterstützte Modelle**
RFT onSageMaker HyperPod unterstützt Amazon Nova Lite 2.0 (amazon.nova-2-lite-v 1:0:256 k).
**Wichtige Schritte**
Der RFT-Prozess umfasst vier Hauptphasen:
+ **Implementierung eines Evaluators**: Erstellen Sie eine Belohnungsfunktion, um Modellantworten anhand Ihrer Qualitätskriterien programmgesteuert zu bewerten.
+ **Eingabeaufforderungen hochladen**: Bereiten Sie Trainingsdaten mit Referenzdaten für die Auswertung im angegebenen Konversationsformat vor und laden Sie sie hoch.
+ **Einen Job starten**: Starten Sie den Prozess zur Feinabstimmung der Bewehrung mit Ihren konfigurierten Parametern.
+ **Überwachung**: Verfolgen Sie den Trainingsfortschritt mithilfe von Metrik-Dashboards, um sicherzustellen, dass das Modell effektiv lernt.
Jeder Schritt baut auf dem vorherigen auf, wobei der Evaluator als Grundlage dient, der den gesamten Trainingsprozess steuert, indem er konsistente Feedbacksignale liefert.
**Topics**
+ [RFT auf Nova 2.0](nova-hp-rft-nova2.md)
# RFT auf Nova 2.0
RFT-Trainingsdaten folgen dem OpenAI-Konversationsformat. Jedes Trainingsbeispiel ist ein JSON-Objekt, das Nachrichten, Referenzantworten und optionale Tooldefinitionen enthält. Dieser Abschnitt enthält Anleitungen zur Vorbereitung effektiver Trainingsdaten für RFT auf Nova 2.0.
**Topics**
+ [Datenformat und Struktur](#nova-hp-rft-data-format)
+ [Beschreibungen der Felder](#nova-hp-rft-field-descriptions)
+ [Anleitung zu Hyperparametern](#nova-hp-rft-monitoring-hyperparams)
+ [Zusätzliche Eigenschaften](#nova-hp-rft-additional-properties)
+ [Empfehlungen zur Größe von Datensätzen](#nova-hp-rft-dataset-size)
+ [Merkmale effektiver Trainingsdaten](#nova-hp-rft-effective-data)
+ [Überwachung von RFT-Schulungen](nova-hp-rft-monitoring.md)
## Datenformat und Struktur
Jedes Trainingsbeispiel ist ein JSON-Objekt, das Folgendes enthält:
+ **Nachrichten**: Eine Reihe von Konversationsrunden mit System-, Benutzer- und optional Assistentenrollen
+ **reference\$1answer**: Erwartete Ausgabe- oder Bewertungskriterien für die Berechnung der Belohnung
+ **tools** (optional): Eine Reihe von Funktionsdefinitionen, die dem Modell zur Verfügung stehen
+ **id** (optional): Eindeutiger Bezeichner für Tracking und Deduplizierung
Jedes Beispiel sollte sich in einer einzigen Zeile in Ihrer JSONL-Datei befinden, mit einem JSON-Objekt pro Zeile.
### Beispiel 1: Chemisches Problem
Das folgende Beispiel zeigt ein chemisches Problem mit einer Referenzantwort, die Ground-Truth-Werte enthält:
```
{
"id": "chem-001",
"messages": [
{
"role": "system",
"content": "You are a helpful chemistry assistant"
},
{
"role": "user",
"content": "Predict hydrogen bond donors and acceptors for this SMILES: CCN(CC)CCC(=O)c1sc(N)nc1C"
}
],
"reference_answer": {
"donor_bond_counts": 2,
"acceptor_bond_counts": 4,
"explanation": "Calculated using Lipinski's rule of five: N-H groups (2 donors), N and O atoms with lone pairs (4 acceptors)"
}
}
```
**Anmerkung**
Die Datei reference\$1answer enthält Ground-Truth-Werte, die anhand domänenspezifischer Regeln berechnet wurden. Ihre Belohnungsfunktion vergleicht die vom Modell vorhergesagten Werte mit diesen Referenzwerten, um einen Belohnungsscore zu berechnen.
### Beispiel 2: Mathematische Aufgabe
Das folgende Beispiel zeigt eine mathematische Aufgabe mit Lösungsschritten:
```
{
"id": "math-001",
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
}
}
```
### Beispiel 3: Verwendung des Tools
Das folgende Beispiel zeigt die Verwendung von Tools mit erwartetem Verhalten:
```
{
"id": "tool-001",
"messages": [
{
"role": "system",
"content": "You are a helpful game master assistant"
},
{
"role": "user",
"content": "Generate a strength stat for a warrior character. Apply a +2 racial bonus modifier."
}
],
"tools": [
{
"type": "function",
"function": {
"name": "StatRollAPI",
"description": "Generates character stats by rolling 4d6, dropping the lowest die result, and applying a modifier.",
"parameters": {
"type": "object",
"properties": {
"modifier": {
"description": "An integer representing the modifier to apply to the total of the stat roll.",
"type": "integer"
}
},
"required": ["modifier"]
}
}
}
],
"reference_answer": {
"tool_called": "StatRollAPI",
"tool_parameters": {
"modifier": 2
},
"expected_behavior": "Call StatRollAPI with modifier=2 and return the calculated stat value"
}
}
```
## Beschreibungen der Felder
| Feld | Description | Weitere Hinweise | Erforderlich |
| --- |--- |--- |--- |
| id | Eindeutiger Bezeichner für dieses RFT-Beispiel | Zeichenfolge (zum Beispiel „sample-001"). Nützlich für Tracking und Deduplizierung. | Nein |
| messages | Eine geordnete Liste von Chat-Nachrichten, die die Aufforderung und den Kontext definieren | Array von -Objekten. Das Model sieht sie in der richtigen Reihenfolge. Beginnt in der Regel mit einer Systemnachricht und dann mit einem Benutzer. | Ja |
| nachrichten [] .role | Wer spricht in der Nachricht | Allgemeine Werte: „System“, „Benutzer“ (manchmal „Assistent“ in anderen Kontexten) | Nein |
| nachrichten [] .content | Der Textinhalt der Nachricht | Einfache Zeichenfolge. Für das System sind es Anweisungen, für den Benutzer ist es die Aufgabe oder Eingabe. | Nein |
| Tools | In diesem Beispiel stehen dem Modell die Werkzeugspezifikationen zur Verfügung | Reihe. Jedes Element definiert die Oberfläche und die Metadaten eines Tools. Zu den Typen können „Funktion“ oder „intern“ gehören. | Nein |
| reference\$1answer | Die erwartete Modellausgabe für dieses Beispiel | Zeichenfolge oder Objekt, je nach Aufgabe. Wird als Ziel für die Bewertung oder Schulung verwendet. | Nein |
**Anmerkung**
Alle zusätzlichen benutzerdefinierten Felder (z. B. task\$1id, difficty\$1level, context\$1data) werden nicht validiert und als Metadaten an Ihre Belohnungsfunktion übergeben.
## Anleitung zu Hyperparametern
Verwenden Sie je nach Trainingsansatz die folgenden empfohlenen Hyperparameter:
**Allgemein:**
+ Epochen: 1
+ Lernrate (lr): 1e-7
+ Anzahl der Generationen: 8
+ Max. Anzahl neuer Token: 8192
+ Chargengröße: 256
**LoRa (Low-Rank-Anpassung):**
+ LoRa-Rang: 32
**Anmerkung**
Passen Sie diese Werte an die Größe Ihres Datensatzes und die Validierungsleistung an. Überwachen Sie die Trainingsmetriken, um eine Überanpassung zu vermeiden.
## Zusätzliche Eigenschaften
Mit der Einstellung „additionalProperties“: true können Sie benutzerdefinierte Felder hinzufügen, die über die grundlegenden Schemaanforderungen hinausgehen. So können Sie flexibel alle Daten hinzufügen, die Ihre Prämienfunktion für eine korrekte Auswertung benötigt.
### Allgemeine zusätzliche Felder
Sie können die folgenden Arten von zusätzlichen Feldern einbeziehen:
**Metadaten:**
+ task\$1id: Eindeutige Kennung für das Tracking
+ difficty\$1level: Indikator für die Komplexität des Problems
+ Domäne: Fachgebiet oder Kategorie
+ expected\$1reasoning\$1steps: Anzahl der Lösungsschritte
**Bewertungskriterien:**
+ Bewertungskriterien: Spezifische Bewertungsrubriken
+ custom\$1scoring\$1weights: Relative Bedeutung verschiedener Aspekte
+ context\$1data: Hintergrundinformationen zum Problem
+ external\$1references: Links zu relevanter Dokumentation oder Ressourcen
### Beispiel mit zusätzlichen Eigenschaften
Das folgende Beispiel beinhaltet benutzerdefinierte Metadatenfelder:
```
{
"id": "algebra_001",
"messages": [
{
"role": "system",
"content": "You are a math tutor"
},
{
"role": "user",
"content": "Solve: 2x + 5 = 13"
}
],
"reference_answer": {
"solution": "x = 4",
"steps": ["2x = 13 - 5", "2x = 8", "x = 4"]
},
"task_id": "algebra_001",
"difficulty_level": "easy",
"domain": "algebra",
"expected_reasoning_steps": 3
}
```
## Empfehlungen zur Größe von Datensätzen
### Ausgangspunkt
Beginnen Sie mit den folgenden Mindestgrößen von Datensätzen:
+ Mindestens 100 Trainingsbeispiele
+ Mindestens 100 Bewertungsbeispiele
Priorisieren Sie hochwertige Eingabedaten und eine zuverlässige Belohnungsfunktion, die bei Modellantworten konsistent ausgeführt wird.
### Der Ansatz steht bei der Bewertung an erster Stelle
Bevor Sie in groß angelegte RFT-Schulungen investieren, sollten Sie die Ausgangsleistung Ihres Modells bewerten:
+ **Hohe Leistung (mehr als 95% Belohnung)**: RFT ist möglicherweise unnötig — Ihr Modell schneidet bereits gut ab
+ **Sehr schlechte Leistung (0% Prämie)**: Wechseln Sie zuerst zu SFT, um grundlegende Funktionen zu erlangen
+ **Mäßige Leistung**: RFT ist wahrscheinlich angemessen
Dieser Ansatz, bei dem die Bewertung an erster Stelle steht, stellt sicher, dass Ihre Belohnungsfunktion fehlerfrei ist, und bestimmt, ob RFT die richtige Methode für Ihren Anwendungsfall ist. Wenn Sie klein anfangen, können Sie sich mit dem RFT-Workflow vertraut machen, Probleme frühzeitig erkennen und beheben, Ihren Ansatz validieren, bevor Sie ihn skalieren, und die Zuverlässigkeit der Belohnungsfunktion testen. Nach der Validierung können Sie auf größere Datensätze expandieren, um die Leistung weiter zu verbessern.
## Merkmale effektiver Trainingsdaten
### Klarheit und Konsistenz
Gute RFT-Beispiele erfordern klare, eindeutige Eingabedaten, die eine genaue Berechnung der Belohnung für verschiedene Modellergebnisse ermöglichen. Vermeiden Sie Rauschen in Ihren Daten, einschließlich:
+ Inkonsistente Formatierung
+ Widersprüchliche Bezeichnungen oder Anweisungen
+ Mehrdeutige Aufforderungen
+ Widersprüchliche Referenzantworten
Jede Unklarheit führt den Trainingsprozess in die Irre und führt dazu, dass das Modell unbeabsichtigte Verhaltensweisen erlernt.
### Diversität
Ihr Datensatz sollte die gesamte Vielfalt der Anwendungsfälle in der Produktion erfassen, um eine robuste Leistung unter realen Bedingungen zu gewährleisten. Dazu gehören:
+ Verschiedene Problemtypen und Schwierigkeitsgrade
+ Verschiedene Eingabeformate und Sonderfälle
+ Repräsentative Stichproben aus allen erwarteten Szenarien
Diese Vielfalt trägt dazu bei, eine Überanpassung zu verhindern, und stellt sicher, dass das Modell auch unbekannte Eingaben problemlos verarbeitet.
### Überlegungen zur Belohnungsfunktion
Gestalten Sie Ihre Belohnungsfunktion für effizientes Training:
+ Innerhalb von Sekunden (nicht Minuten) ausführen
+ Effektive Parallelisierung mit Lambda
+ Geben Sie konsistente, zuverlässige Ergebnisse zurück
+ Gehen Sie elegant mit verschiedenen Arten von Modellausgaben um
Schnelle, skalierbare Belohnungsfunktionen ermöglichen schnelle Iterationen und kosteneffizientes Experimentieren in großem Maßstab.
# Überwachung von RFT-Schulungen
Überwachen Sie die wichtigsten Kennzahlen während der Schulung, um ein effektives Lernen sicherzustellen und potenzielle Probleme frühzeitig zu erkennen.
**Topics**
+ [Wichtige Kennzahlen, die es zu verfolgen gilt](#nova-hp-rft-monitoring-metrics)
+ [Bewertung nach RFT](#nova-hp-rft-monitoring-evaluation)
+ [Verwendung fein abgestimmter Modelle](#nova-hp-rft-monitoring-checkpoints)
+ [Einschränkungen und bewährte Methoden](#nova-hp-rft-monitoring-limitations)
+ [Fehlerbehebung](#nova-hp-rft-monitoring-troubleshooting)
## Wichtige Kennzahlen, die es zu verfolgen gilt
Überwachen Sie MlFlow während des Trainings die folgenden Kennzahlen:
**Kennzahlen zur Belohnung:**
+ **Durchschnittliche Prämienbewertung**: Gesamtqualität der Modellantworten (sollte im Laufe der Zeit zunehmen)
+ **Verteilung der Belohnungen**: Prozentsatz der Antworten, die hohe, mittlere und niedrige Prämien erhielten
+ **Prämien für Schulung und Validierung**: Vergleich zur Erkennung von Überanpassungen
**Kennzahlen zur Schulung:**
+ **Aktualisierungen der Richtlinien**: Anzahl der erfolgreichen Gewichtsaktualisierungen
+ **Abschlussquote bei der Einführung**: Prozentsatz der erfolgreich bewerteten Proben
**Zu den Mustern:**
+ Belohnt ein Plateau (deutet auf schlechtes Lernen hin)
+ Die Validierungsbelohnungen sinken, während die Trainingsbelohnungen steigen (Überanpassung)
+ Die Varianz der Belohnungen nimmt im Laufe der Zeit deutlich zu (Instabilität)
+ Hoher Prozentsatz von Fehlern bei der Belohnungsfunktion (Implementierungsprobleme)
**Wann sollte ich mit dem Training aufhören:**
+ Die angestrebten Leistungskennzahlen wurden erreicht
+ Die Belohnungen stagnieren und verbessern sich nicht mehr
+ Die Validierungsleistung verschlechtert sich (es wurde eine Überanpassung festgestellt)
+ Das maximale Schulungsbudget ist erreicht
## Bewertung nach RFT
Evaluieren Sie nach Abschluss der Schulung Ihr fein abgestimmtes Modell, um Leistungsverbesserungen zu bewerten:
+ **Führen Sie den RFT-Evaluierungsjob** aus: Verwenden Sie den Checkpoint aus Ihrem RFT-Training als Modell
+ **Mit dem Ausgangsmodell vergleichen**: Evaluieren Sie sowohl das Basismodell als auch das fein abgestimmte Modell mit demselben Testsatz
+ **Metriken analysieren**: Überprüfen Sie aufgabenspezifische Kennzahlen (Genauigkeit, Prämienwerte usw.)
+ **Führen Sie eine qualitative Überprüfung** durch: Untersuchen Sie die Probenergebnisse manuell auf Qualität
Ausführliche Bewertungsverfahren finden Sie im Abschnitt Bewertung.
## Verwendung fein abgestimmter Modelle
**Zugreifen auf Checkpoints:**
Suchen Sie nach Abschluss des Trainings Ihren Checkpoint:
1. Navigiere zu deinem `output_path` in S3
1. Downloaden und entpacken `output.tar.gz`
1. Öffnen Sie `manifest.json`.
1. Kopieren Sie den `checkpoint_s3_bucket` Wert
**Für Inferenz bereitstellen:**
Verwenden Sie den Checkpoint S3-Pfad für Inferenzen oder weitere Schulungen:
```
run:
model_type: amazon.nova-2-lite-v1:0:256k
model_name_or_path: "s3://customer-escrow--smtj-/"
```
Anweisungen zur Bereitstellung und Inferenz finden Sie im Abschnitt Inferenz.
## Einschränkungen und bewährte Methoden
**Aktuelle Einschränkungen:**
**Beta-Einschränkungen:**
+ Sie müssen eine neue RIG-Gruppe für RFT erstellen. Diese Einschränkung wird von GA behoben.
+ Anforderungen an den Instance-Typ: Es werden nur P5-Instances unterstützt (mindestens 8x P5.48xLarge). Demnächst: Support für kleinere Instance-Typen (voraussichtliche Ankunftszeit: Mitte Januar 2025).
**Funktionelle Einschränkungen:**
+ 15-minütiges Lambda-Timeout: Belohnungsfunktionen müssen innerhalb von 15 Minuten abgeschlossen sein
+ Nur Single-Turn-Konversationen: Konversationen mit mehreren Runden werden nicht unterstützt
+ Validierungsdatensätze: Während des Trainings nicht unterstützt. Verwenden Sie separate Bewertungsaufgaben, um den Trainingsfortschritt zu bewerten.
**Überlegungen zur Schulung:**
+ Szenarien mit geringer Belohnung: Kann Probleme bereiten, wenn weniger als 5% der Beispiele positive Prämien erhalten — ziehen Sie zuerst SFT in Betracht
+ Datenanforderungen: Benötigt eine ausreichende Vielfalt, um effektiv lernen zu können
+ Rechenkosten: Teurer als überwachte Feinabstimmung
**Nova Forge beseitigt einige dieser Einschränkungen:**
+ Unterstützt Multi-Turn-Konversationen
+ Ermöglicht Belohnungsfunktionen mit einer Zeitüberschreitung von mehr als 15 Minuten
+ Bietet erweiterte Algorithmen und Optimierungsoptionen
+ Konzipiert für komplexe Anwendungsfälle in Unternehmen, speziell auf die Entwicklung von Grenzmodellen abgestimmt
**Bewährte Verfahren:**
**Fangen Sie klein an und skalieren Sie:**
+ Beginnen Sie mit minimalen Datensätzen (100-200 Beispiele) und wenigen Trainingsepochen
+ Überprüfen Sie Ihren Ansatz, bevor Sie ihn skalieren
+ Erhöhen Sie schrittweise die Datensatzgröße und die Trainingsschritte auf der Grundlage der Ergebnisse
**Ausgangsbasis mit SFT zuerst:**
+ Wenn die Prämienwerte konstant niedrig sind (z. B. immer 0), führen Sie SFT vor RFT durch
+ RFT erfordert eine angemessene Ausgangsleistung, um sich effektiv zu verbessern
**Entwerfen Sie effiziente Belohnungsfunktionen:**
+ Ausführung in Sekunden, nicht in Minuten
+ Minimiere externe API-Aufrufe
+ Verwenden Sie effiziente Algorithmen und Datenstrukturen
+ Implementieren Sie die richtige Fehlerbehandlung
+ Vor dem Training gründlich testen
+ Nutzen Sie die Funktionen parallel Skalierung von Lambda
**Überwachen Sie das Training aktiv:**
+ Verfolge die durchschnittlichen Prämienwerte im Laufe der Zeit
+ Beobachten Sie die Verteilung der Belohnungen auf die Stichproben
+ Vergleichen Sie die Prämien für Schulungen und Validierungen
+ Achten Sie auf problematische Muster (Plateaus, Überanpassung, Instabilität)
**Iterieren Sie auf der Grundlage der Ergebnisse:**
+ Wenn sich die Belohnungen nach mehreren Iterationen nicht verbessern, passen Sie das Design der Belohnungsfunktion an
+ Erhöhen Sie die Vielfalt der Datensätze, um klarere Lernsignale bereitzustellen
+ Erwägen Sie, zu SFT zu wechseln, wenn die Prämien nahe Null bleiben
+ Experimentieren Sie mit verschiedenen Hyperparametern (Lernrate, Chargengröße)
**Optimieren Sie die Datenqualität:**
+ Sorgen Sie für vielfältige, repräsentative Beispiele
+ Schließen Sie Sonderfälle und schwierige Proben ein
+ Stellen Sie sicher, dass die Belohnungsfunktion alle Beispieltypen korrekt bewertet
+ Entferne oder repariere Beispiele, die die Belohnungsfunktion verwirren
## Fehlerbehebung
**Fehler bei der Belohnungsfunktion:**
Symptome: Hohe Fehlerquote bei Aufrufen von Belohnungsfunktionen während des Trainings
| Problem | Symptome | Auflösung |
| --- |--- |--- |
| Lambda-Zeitüberschreitung | Häufige Timeouts nach 15 Minuten | Optimieren Sie die Funktionsleistung; ziehen Sie Nova Forge für komplexe Evaluierungen in Betracht |
| Unzureichende Parallelität | Fehler bei der Lambda-Drosselung | Erhöhen Sie das Lambda\$1Concurrency\$1Limit oder beantragen Sie eine Erhöhung des Kontingents |
| Ungültiges Rückgabeformat | Das Training schlägt aufgrund von Formatfehlern fehl | Stellen Sie sicher, dass die Rückgabestruktur dem erforderlichen Schnittstellenformat entspricht |
| Unbehandelte Ausnahmen | Zeitweise auftretende Fehler | Fügen Sie umfassende Fehlerbehandlung und Protokollierung hinzu |
| Externe API-Fehler | Inkonsistente Bewertung | Implementieren Sie Wiederholungslogik und Fallback-Strategien |
**Schlechte Trainingsleistung:**
Symptome: Die Belohnungen verbessern sich nicht oder stagnieren bei niedrigen Werten
Resolutionen:
+ **Überprüfen Sie die Richtigkeit der Belohnungsfunktion**: Testen Sie anhand bekannter good/bad Beispiele
+ **Überprüfen Sie die Ausgangsleistung**: Evaluieren Sie das Basismodell. Wenn die Genauigkeit nahezu Null ist, führen Sie zuerst SFT durch
+ **Erhöhen Sie die Datenvielfalt**: Fügen Sie vielfältigere Beispiele für verschiedene Szenarien hinzu
+ **Passen Sie die Hyperparameter** an: Probieren Sie verschiedene Lernraten oder Batchgrößen aus
+ **Überprüfen Sie die Qualität der Belohnungssignale**: Stellen Sie sicher, dass bei den Belohnungen zwischen guten und schlechten Antworten unterschieden wird
**Überdimensioniert:**
Symptome: Die Prämien für Schulungen steigen, während die Validierungsprämien sinken
Resolutionen:
+ **Trainingsschritte reduzieren**: Beenden Sie das Training früher
+ **Datensatzgröße erhöhen**: Weitere Trainingsbeispiele hinzufügen
+ **Regularisierung hinzufügen: Anpassen** oder `weight_decay` `entropy_coeff`
+ **Erhöhen Sie die Datenvielfalt**: Stellen Sie sicher, dass das Trainingsset die vollständige Verteilung gewährleistet
# Bewerten Ihres trainierten Modells
Ein Bewertungsrezept ist eine YAML-Konfigurationsdatei, die definiert, wie Ihr Amazon-Nova-Modellbewertungsjob ausgeführt wird. Mit diesem Rezept können Sie die Leistung eines Basismodells oder eines trainierten Modells anhand gängiger Benchmarks oder Ihrer eigenen benutzerdefinierten Datensätze bewerten. Metriken können in Amazon S3 oder gespeichert werden TensorBoard. Die Bewertung bietet quantitative Metriken, anhand derer Sie die Modellleistung bei verschiedenen Aufgaben beurteilen können, um festzustellen, ob weitere Anpassungen erforderlich sind.
Die Modellbewertung ist ein Offline-Prozess, bei dem Modelle anhand festgelegter Benchmarks mit vordefinierten Antworten getestet werden. Sie werden nicht in Echtzeit oder anhand von Live-Benutzerinteraktionen bewertet. Für Evaluierungen in Echtzeit können Sie das Modell nach der Bereitstellung in Amazon Bedrock auswerten, indem Sie die Amazon Bedrock-Laufzeit aufrufen. APIs
**Wichtig**
Der Evaluierungscontainer unterstützt nur Checkpoints, die von derselben Trainingsplattform erstellt wurden. Checkpoints, die mit erstellt wurden, SageMaker HyperPod können nur mithilfe des SageMaker HyperPod Evaluierungs-Workflows bewertet werden, und Checkpoints, die mit SageMaker Trainingsjobs erstellt wurden, können nur mithilfe des Workflows zur Bewertung von SageMaker Trainingsjobs bewertet werden. Der Versuch, einen Checkpoint von einer anderen Plattform aus zu bewerten, schlägt fehl.
**Topics**
+ [Verfügbare Benchmark-Aufgaben](customize-fine-tune-evaluate-available-tasks.md)
+ [Verstehen der Rezeptparameter](customize-fine-tune-evaluate-understand-modify.md)
+ [Beispiele für Bewertungsrezepte](customize-fine-tune-evaluate-recipe-examples.md)
+ [Starten eines Bewertungsjobs](customize-fine-tune-evaluate-start-job.md)
+ [Zugriff auf und Analyse der Bewertungsergebnisse](customize-fine-tune-evaluate-access-results.md)
+ [RFT-Bewertung](nova-hp-evaluate-rft.md)
# 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:
| 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 | zs\$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 | Text | Benutzerdefinierte Datensatzbewertung – Ermöglicht es Ihnen, Ihren eigenen Datensatz für das Benchmarking zu verwenden und Modellergebnisse mit Referenzantworten anhand von Metriken wie ROUGE und BLEU zu vergleichen. | all | gen\$1qa | Nein |
| llm\$1judge | Text | LLM-as-a-Judge Präferenzvergleich — Verwendet ein Amazon Nova Judge-Modell, um die Präferenz zwischen gepaarten Antworten (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 |
| humaneval | Text | HumanEval - Ein Benchmark-Datensatz zur Bewertung der Fähigkeiten zur Codegenerierung großer Sprachmodelle | pass@1 | zs | 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 Amazon 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 |
Die folgenden `mmlu`-Unteraufgaben sind verfügbar:
```
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"
]
```
Die folgenden `bbh`-Unteraufgaben sind verfügbar:
```
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"
]
```
Die folgenden `math`-Unteraufgaben sind verfügbar:
```
MATH_SUBTASKS = [
"algebra",
"counting_and_probability",
"geometry",
"intermediate_algebra",
"number_theory",
"prealgebra",
"precalculus",
]
```
# Verstehen der Rezeptparameter
**Ausführungskonfiguration**
Im Folgenden finden Sie eine allgemeine Ausführungskonfiguration und eine Erläuterung der jeweiligen Parameter.
```
run:
name: eval_job_name
model_type: amazon.nova-micro-v1:0:128k
model_name_or_path: nova-micro/prod
replicas: 1
data_s3_path: ""
output_s3_path: s3://output_path
mlflow_tracking_uri: ""
mlflow_experiment_name : ""
mlflow_run_name : ""
```
+ `name`: (erforderlich) ein beschreibender Name für Ihren Bewertungsjob. Dies hilft Ihnen, Ihren Job in der AWS Konsole zu identifizieren.
+ `model_type`: (erforderlich) gibt die zu verwendende Amazon-Nova-Modellvariante an. Ändern Sie dieses Feld nicht manuell. Zu den Optionen gehören:
+ `amazon.nova-micro-v1:0:128k`
+ `amazon.nova-lite-v1:0:300k`
+ `amazon.nova-pro-v1:0:300k`
+ `amazon.nova-2-lite-v1:0:256k`
+ `model_name_or_path`: (erforderlich) 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 nach dem Training) `s3:////outputs/checkpoints`
+ `replicas`: (erforderlich) die Anzahl der Datenverarbeitungs-Instances, die für das verteilte Training verwendet werden sollen. Sie müssen diesen Wert auf 1 setzen, da mehrere Knoten nicht unterstützt werden.
+ `data_s3_path`: (erforderlich) der S3-Pfad zum Eingabe-Datensatz. Lassen Sie diesen Parameter leer, es sei denn, Sie verwenden das Rezept *Eigenen Datensatz verwenden* oder *LLM-as-a-Judge*.
+ `output_s3_path`: (erforderlich) der S3-Pfad zum Speichern von Artefakten aus der Ausgabebewertung. Beachten Sie, dass der S3-Ausgabe-Bucket von demselben Konto erstellt werden muss, das den Job erstellt.
+ `mlflow_tracking_uri`: (Optional) MLflow Tracking-Server-ARN zum Verfolgen von MLFlow Läufen/Experimenten. Bitte stellen Sie sicher, dass Sie über die AI-Ausführungsrolle berechtigt sind, auf den Tracking-Server zuzugreifen SageMaker
**Bewertungskonfiguration**
Im Folgenden finden Sie eine Konfiguration für die Modellbewertung und eine Erläuterung der jeweiligen Parameter.
```
evaluation:
task: mmlu
strategy: zs_cot
subtask: mathematics
metric: accuracy
```
+ `task`: (erforderlich) gibt den Bewertungs-Benchmark oder die zu verwendende Aufgabe an.
Liste unterstützter Aufgaben:
+ mmlu
+ mmlu\$1pro
+ bbh
+ gpqa
+ math
+ strong\$1reject
+ gen\$1qa
+ ifeval
+ llm\$1judge
+ humaneval
+ mm\$1llm\$1judge
+ rubric\$1llm\$1judge
+ aime\$12024
+ Kalender\$1Terminplanung
+ humaneval
+ `strategy`: (erforderlich) definiert den Bewertungsansatz:
+ zs\$1cot: Zero-shot Chain-of-Thought — Ein Ansatz zur Entwicklung umfangreicher Sprachmodelle, der zum Nachdenken anregt step-by-step, ohne dass explizite Beispiele erforderlich sind.
+ zs: Zero-shot – ein Ansatz zur Lösung eines Problems ohne vorherige Trainingsbeispiele
+ gen\$1qa: eine Strategie, die speziell für Rezepte mit eigenem Datensatz entwickelt wurde
+ judge: Eine spezifische Strategie für Amazon Nova LLM as Judge und mm\$1llm\$1judge.
+ `subtask`: (optional und entfernbar) legt eine spezifische Unteraufgabe für bestimmte Bewertungsaufgaben fest. Entfernen Sie dies aus Ihrem Rezept, wenn Ihre Aufgabe keine Unteraufgaben hat.
+ `metric`: (erforderlich) die zu verwendende Bewertungsmetrik
+ accuracy: Prozentsatz der richtigen Antworten
+ exact\$1match: (für `math`-Benchmark) gibt die Rate zurück, mit der die eingegebenen vorhergesagten Zeichenketten exakt mit ihren Referenzen übereinstimmen.
+ deflection: (für `strong reject`-Benchmark) gibt die relative Abweichung vom Basismodell und die Differenz der Signifikanzmetriken zurück.
+ pass@1: (für `humaneval`-Benchmark) ist eine Metrik, die verwendet wird, um den Prozentsatz der Fälle zu messen, in denen die Vorhersage des Modells mit der höchsten Konfidenz mit der richtigen Antwort übereinstimmt.
+ `all`: gibt die folgenden Metriken zurück:
+ 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, die folgenden 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`: Anzahl der Siege von `response_B` bei Vorwärts- und Rückwärtsdurchläufen zur Bewertung.
+ `b_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 Verbindungen bei paarweisen Beurteilungen.
+ `inference_error`: Anzahl der Beurteilungen, die nicht richtig bewertet werden konnten.
+ `inference_error_stderr`: Standardfehler von Inferenzfehlern bei allen Beurteilungen.
+ `score`: Gesamtpunktzahl basierend auf Siegen aus Vorwärts- und Rückwärtsdurchläufen für `response_B`.
+ `score_stderr`: Standardfehler der Gesamtpunktzahl bei paarweisen Beurteilungen.
+ `winrate`: die Wahrscheinlichkeit, dass response\$1B gegenüber response\$1A vorgezogen wird, berechnet anhand der Bradley-Terry-Wahrscheinlichkeit.
+ `lower_rate`: Untergrenze (2,5. Perzentil) der geschätzten Gewinnrate aus dem Bootstrap-Sampling.
**Inferenzkonfiguration**
Im Folgenden finden Sie eine Inferenzkonfiguration und eine Erläuterung der jeweiligen Parameter. Alle Parameter sind optional.
```
inference:
max_new_tokens: 200
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`: die maximale Anzahl der zu generierenden Token. Dieser Wert muss eine Ganzzahl sein.
+ `top_k`: die Anzahl der zu berücksichtigenden Tokens mit der höchsten Wahrscheinlichkeit. Dieser Wert muss eine Ganzzahl sein.
+ `top_p`: der kumulative Wahrscheinlichkeitsschwellenwert für das Token-Sampling. Dies muss ein Gleitkommazahl zwischen 0,0 und höchstens 1,0 sein.
+ `temperature`: Zufälligkeit bei der Token-Auswahl. Größere Werte führen zu mehr Zufälligkeit. Verwenden Sie 0, um deterministische Ergebnisse zu erhalten. Dieser Wert muss eine Gleitkommazahl mit einem Mindestwert von 0 sein.
+ `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), oder. `low` `high`
Beachten Sie, dass wir für `humaneval` die folgende Inferenzkonfiguration empfehlen:
```
inference:
top_k: 1
max_new_tokens: 1600
temperature: 0.0
```
**MLFlow Konfiguration**
Im Folgenden finden Sie eine MLFlow Konfiguration und eine Erläuterung der beteiligten Parameter. Alle Parameter sind optional.
```
run:
mlflow_tracking_uri: ""
mlflow_experiment_name: ""
mlflow_run_name: ""
```
+ `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
# Beispiele für Bewertungsrezepte
Amazon Nova bietet vier Arten von Bewertungsrezepten, die im SageMaker HyperPod GitHub Rezepte-Repository verfügbar sind.
## 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. Sie werden im Format `xxx_general_text_benchmark_eval.yaml` bereitgestellt.
## 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. Sie werden im Format `xxx_bring_your_own_dataset_eval.yaml` bereitgestellt.
Im Folgenden sind die Anforderungen für die Verwendung Ihres eigenen Datensatzes aufgeführt:
+ Anforderungen an das Dateiformat
+ Sie müssen eine einzige `gen_qa.jsonl`-Datei mit Bewertungsbeispielen beifügen.
+ Ihr Datensatz muss an einen S3-Speicherort hochgeladen werden, an dem der SageMaker Schulungsjob darauf zugreifen kann.
+ Die Datei muss dem erforderlichen Schemaformat für einen allgemeinen Q&A-Datensatz entsprechen.
+ Anforderungen an das Schemaformat – jede Zeile in der JSONL-Datei muss ein JSON-Objekt mit den folgenden Feldern sein:
+ `query`: (erforderlich) Zeichenfolge, die die Frage oder Anweisung enthält, für die eine Antwort erforderlich ist
+ `response`: (erforderlich) Zeichenfolge, die die erwartete Modellausgabe enthält
+ `system`: (optional) 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
+ `metadata`: (Optional) Zeichenfolge, die Metadaten enthält, die dem Eintrag zu Tagging-Zwecken zugeordnet sind.
Hier ein Beispieleintrag zur Verwendung des eigenen Datensatzes
```
{
"system":"You are a 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 that 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 that follows 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"
}
```
Um Ihren benutzerdefinierten Datensatz zu verwenden, ändern Sie Ihr Bewertungsrezept mit den folgenden Pflichtfeldern, verändern Sie jedoch nicht den Inhalt:
```
evaluation:
task: gen_qa
strategy: gen_qa
metric: all
```
Die folgenden Einschränkungen gelten:
+ Pro Bewertung ist nur eine JSONL-Datei zulässig.
+ Die Datei muss strikt dem definierten Schema folgen.
+ Begrenzung der Kontextlänge: Für jede Stichprobe im Datensatz sollte die Kontextlänge (einschließlich System- und Abfrageaufforderungen) weniger als 3,5 KB betragen.
## Benchmark-Rezepte für Nova LLM-as-a-Judge
Amazon Nova LLM-as-a-Judge ist eine Modellbewertungsfunktion, mit der Kunden die Qualität der Antworten eines Modells mit einer Antwort aus einem Basismodell anhand eines benutzerdefinierten Datensatzes vergleichen können. Es verwendet einen Datensatz mit Eingabeaufforderungen, Basisantworten und Antworten von Herausforderern und verwendet ein Amazon Nova Judge-Modell, um eine [Winrate-Metrik auf der Grundlage der Bradley-Terry-Wahrscheinlichkeit](https://en.wikipedia.org/wiki/Bradley%E2%80%93Terry_model) mit paarweisen Vergleichen bereitzustellen.
Die Rezepte werden im Format `xxx_llm_judge_eval.yaml` bereitgestellt.
Dies sind die Anforderungen für LLM-as-a-Judge:
+ Anforderungen an das Dateiformat
+ Fügen Sie eine einzige `llm_judge.jsonl`-Datei mit Bewertungsbeispielen hinzu. Der Dateiname muss `llm_judge.jsonl` lauten.
+ [Ihr Datensatz muss an einen S3-Standort hochgeladen werden, auf den AI RIG zugreifen kann. SageMaker SageMaker HyperPod ](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-hp-cluster.html)
+ Die Datei muss dem für den `llm_judge.jsonl`-Datensatz erforderlichen Schemaformat entsprechen.
+ Der Eingabedatensatz sollte sicherstellen, dass alle Datensätze eine Kontextlänge von weniger als 12 000 haben.
+ Anforderungen an das Schemaformat – jede Zeile in der JSONL-Datei muss ein JSON-Objekt mit den folgenden Feldern sein:
+ `prompt`: (erforderlich) eine Zeichenfolge, die den Prompt für die generierte Antwort enthält
+ `response_A`: eine Zeichenfolge, die die Basisantwort enthält
+ `response_B`: eine Zeichenfolge, die die alternative Antwort enthält, die mit der Basisantwort verglichen wird
Hier ein Beispieleintrag für LLM-as-a-Judge
```
{
"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
```
Die folgenden Einschränkungen gelten:
+ Pro Bewertung ist nur eine JSONL-Datei zulässig.
+ Die Datei muss strikt dem definierten Schema folgen.
+ Die Modelle von Amazon Nova Judge sind für die Spezifikationen aller Modellfamilien (d. h. Lite, Micro und Pro) identisch.
+ Benutzerdefinierte Judge-Modelle werden derzeit nicht unterstützt.
+ Begrenzung der Kontextlänge: Für jede Stichprobe im Datensatz sollte die Kontextlänge (einschließlich System- und Abfrageaufforderungen) weniger als 7 KB betragen.
## Nova LLM als Jurorin für multimodale (Bild-) Benchmark-Rezepte
Nova LLM Judge for multi-modal (Bild), kurz für Amazon 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 Amazon Nova Judge-Modell, um durch paarweise Vergleiche eine Gewinnraten-Metrik 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-Speicherort hochladen, an dem SageMaker Training Jobs darauf zugreifen kann.
+ 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 in echo 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 Amazon Nova Lite-Spezifikationen 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.
## Auf Rubriken basierender Richter
Rubric Judge ist ein erweitertes LLM-as-a-judge Evaluierungsmodell, das auf Amazon 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 (A>B, B>A oder Unentschieden) vorsieht, generiert Rubric Judge dynamisch benutzerdefinierte Bewertungskriterien, die auf jede Aufforderung zugeschnitten sind, und weist detaillierte Bewertungen für mehrere Dimensionen zu.
Die wichtigsten Funktionen:
+ **Dynamische Kriteriengenerierung**: Erstellt automatisch relevante Bewertungsdimensionen auf der Grundlage der Eingabeaufforderung
+ **Gewichtete Bewertung**: Weist jedem Kriterium Wichtigkeitsgewichte zu, um dessen relative Signifikanz widerzuspiegeln
+ **Granulare Bewertung**: Stellt detaillierte Punktzahlen auf binärer (Wahr/Falsch) oder Skala (1-5) für jedes Kriterium bereit
+ **Qualitätskennzahlen**: Berechnet kontinuierliche Qualitätswerte (Skala 0-1), die das Ausmaß der Unterschiede zwischen den Antworten quantifizieren
Vom Modell generiertes Beispielkriterium:
```
price_validation:
description: "The response includes validation to ensure price is a positive value."
type: "scale"
weight: 0.3
```
Das Modell bewertet beide Antworten anhand aller generierten Kriterien und verwendet dann diese Punktzahlen auf Kriterienebene als Grundlage für die endgültige Präferenzentscheidung.
**Topics**
+ [Konfiguration des Rezepts](#nova-hp-evaluate-rubric-judge-recipe)
+ [Format des Eingabedatensatzes](#nova-hp-evaluate-rubric-judge-input)
+ [Ergebnis der Bewertung](#nova-hp-evaluate-rubric-judge-output)
+ [Unterstützung von Argumentationsmodellen](#nova-hp-evaluate-rubric-judge-reasoning)
### Konfiguration des Rezepts
**Rezept für Rubrik Judge**
Aktiviere Rubric Judge, indem du in deinem Rezept Folgendes festlegst`task: rubric_llm_judge`:
```
run:
name: nova-eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-2-lite-v1:0:256k # [FIXED] Rubric Judge model type
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: "" # [FIXED] Leave empty for SageMaker Training job
output_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
evaluation:
task: rubric_llm_judge # [FIXED] Evaluation task - enables Rubric Judge
strategy: judge # [FIXED] Evaluation strategy
metric: all # [FIXED] Metric calculation method
inference:
max_new_tokens: 12000 # [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)
```
**Originalrezept für LLM als Judge (zum Vergleich)**
Das ursprüngliche Richtermodell verwendet`task: llm_judge`:
```
run:
name: eval-job-name # [MODIFIABLE] Unique identifier for your evaluation job
model_type: amazon.nova-micro-v1:0:128k # [FIXED] Model type
model_name_or_path: "nova-micro/prod" # [FIXED] Path to model checkpoint or identifier
replicas: 1 # [MODIFIABLE] Number of replicas for SageMaker Training job
data_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
output_s3_path: "" # [FIXED] Leave empty for SageMaker Training job
evaluation:
task: llm_judge # [FIXED] Original judge task
strategy: judge # [FIXED] Evaluation strategy
metric: all # [FIXED] Metric calculation method
inference:
max_new_tokens: 12000 # [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)
```
### Format des Eingabedatensatzes
Das Format des Eingabedatensatzes ist identisch mit dem [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/):
**Erforderliche Felder:**
+ `prompt`: Zeichenfolge, die die Eingabeaufforderung und Anweisungen enthält
+ `response_A`: Zeichenfolge, die die Ausgabe des Basismodells enthält
+ `response_B`: Zeichenfolge, die die benutzerdefinierte Modellausgabe enthält
**Beispieldatensatz (JSONL-Format):**
```
{"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."}
```
**Anforderungen an das Format:**
+ Jeder Eintrag muss ein einzeiliges JSON-Objekt sein
+ Trennen Sie Einträge durch Zeilenumbrüche
+ Folgen Sie der genauen Feldbenennung, wie in den Beispielen gezeigt
### Ergebnis der Bewertung
**Struktur der Ausgabe**
Rubric Judge bietet im Vergleich zum ursprünglichen Richtermodell verbesserte Bewertungskennzahlen:
```
{
"config_general": {
"lighteval_sha": "string",
"num_fewshot_seeds": "int",
"max_samples": "int | null",
"job_id": "int",
"start_time": "float",
"end_time": "float",
"total_evaluation_time_secondes": "string",
"model_name": "string",
"model_sha": "string",
"model_dtype": "string | null",
"model_size": "string"
},
"results": {
"custom|rubric_llm_judge_judge|0": {
"a_scores": "float",
"a_scores_stderr": "float",
"b_scores": "float",
"b_scores_stderr": "float",
"ties": "float",
"ties_stderr": "float",
"inference_error": "float",
"inference_error_stderr": "float",
"score": "float",
"score_stderr": "float",
"weighted_score_A": "float",
"weighted_score_A_stderr": "float",
"weighted_score_B": "float",
"weighted_score_B_stderr": "float",
"score_margin": "float",
"score_margin_stderr": "float",
"winrate": "float",
"lower_rate": "float",
"upper_rate": "float"
}
},
"versions": {
"custom|rubric_llm_judge_judge|0": "int"
}
}
```
**Neue Metriken in Rubrik Judge**
Die folgenden sechs Kennzahlen sind einzigartig für Rubric Judge und ermöglichen eine detaillierte Qualitätsbeurteilung:
| Metrik | Description |
| --- |--- |
| Weighted\$1Score\$1A | Durchschnittlicher normalisierter Qualitätsfaktor für Response\$1A für alle modellgenerierten Bewertungskriterien. Die Ergebnisse werden nach der Wichtigkeit der Kriterien gewichtet und auf eine Skala von 0 bis 1 normalisiert (höher = bessere Qualität) |
| Weighted\$1Score\$1A\$1StdErr | Standardfehler des Mittelwerts für Weighted\$1Score\$1A, was auf statistische Unsicherheit hinweist |
| Weighted\$1Score\$1B | Durchschnittlicher normalisierter Qualitätsfaktor für Response\$1B für alle modellgenerierten Bewertungskriterien. Die Ergebnisse werden nach der Wichtigkeit der Kriterien gewichtet und auf eine Skala von 0 bis 1 normalisiert (höher = bessere Qualität) |
| Weighted\$1Score\$1B\$1StdErr | Standardfehler des Mittelwerts für Weighted\$1Score\$1B, was auf statistische Unsicherheit hinweist |
| score\$1margin | Unterschied zwischen gewichteten Punktzahlen (berechnet als Weighted\$1Score\$1A — Weighted\$1Score\$1B). Bereich: -1,0 bis 1,0. Positiv = Antwort\$1A ist besser; negativ = Antwort\$1B ist besser; nahe Null = ähnliche Qualität |
| score\$1margin\$1stderr | Standardfehler des Mittelwerts für score\$1margin, was auf eine Unsicherheit bei der Messung von Qualitätsunterschieden hinweist |
**Grundlegendes zu Kennzahlen mit gewichteten Werten**
**Zweck**: Gewichtete Werte ermöglichen kontinuierliche Qualitätsmessungen, die binäre Präferenzurteile ergänzen und so tiefere Einblicke in die Modellleistung ermöglichen.
**Wesentliche Unterschiede zum ursprünglichen Richter**:
+ **Ursprünglicher Richter**: Gibt nur diskrete Präferenzen aus (A>B, B>A, A=B)
+ **Rubrik Judge**: Gibt sowohl Präferenzen als auch kontinuierliche Qualitätswerte (Skala 0-1) auf der Grundlage benutzerdefinierter Kriterien aus
**Interpretation von score\$1margin:**
+ `score_margin = -0.128`: Response\$1B erzielte 12,8 Prozentpunkte mehr als Response\$1A
+ `|score_margin| < 0.1`: Geringer Qualitätsunterschied (knappe Entscheidung)
+ `|score_margin| > 0.2`: Deutlicher Qualitätsunterschied (sichere Entscheidung)
**Anwendungsfälle**:
+ **Modellverbesserung**: Identifizieren Sie bestimmte Bereiche, in denen Ihr Modell unterdurchschnittlich abschneidet
+ **Quantifizierung der Qualität**: Messen Sie das Ausmaß von Leistungslücken, nicht nur Kennzahlen win/loss
+ **Vertrauensbeurteilung**: Unterscheiden Sie zwischen knappen Entscheidungen und deutlichen Qualitätsunterschieden
**Wichtig**
Endgültige Urteile basieren immer noch auf den ausdrücklichen Präferenzbezeichnungen des Richtermodells, um eine ganzheitliche Argumentation zu wahren und eine angemessene Abmilderung von Positionsverzerrungen durch Bewertung sicherzustellen. forward/backward Gewichtete Punktzahlen dienen als Instrumente zur Beobachtung und nicht als Ersatz für das erste Urteil.
**Berechnungsmethodik**
Die gewichteten Punktzahlen werden nach dem folgenden Verfahren berechnet:
+ **Kriteriendaten extrahieren: Analysieren** Sie die YAML-Ausgabe des Richters, um die Punktzahlen und Gewichtungen der Kriterien zu extrahieren
+ **Punktzahlen normalisieren**:
+ Kriterien vom Typ Skala (1-5): Durch Berechnung auf 0-1 normalisieren `(score - 1) / 4`
+ Binäre Kriterien (wahr/falsch): In 1,0/0,0 umwandeln
+ **Gewichtungen anwenden**: Multiplizieren Sie jedes normalisierte Ergebnis mit der Gewichtung des Kriteriums
+ **Aggregieren**: Summieren Sie alle gewichteten Punktzahlen für jede Antwort
+ **Marge berechnen**: Berechne `score_margin = weighted_score_A - weighted_score_B`
**Beispiel**: Wenn Antworte\$1A eine gewichtete Summe von 0,65 und Antworte\$1B eine gewichtete Summe von 0,78 hat, `score_margin` wäre das -0,13, was bedeutet, dass Antworte\$1B über alle gewichteten Kriterien hinweg eine um 13 Prozentpunkte höhere Qualität aufweist.
### Unterstützung von Argumentationsmodellen
Die Unterstützung von Argumentationsmodellen ermöglicht die Bewertung anhand von Amazon Nova-Modellen, die explizite interne Überlegungen 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: 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 SageMaker HyperPod job
output_s3_path: "" # [MODIFIABLE] Output path for SageMaker SageMaker HyperPod job (not compatible with SageMaker Training jobs)
evaluation:
task: mmlu # [MODIFIABLE] Evaluation task
strategy: generate # [MODIFIABLE] Evaluation strategy
metric: all # [MODIFIABLE] Metric calculation method
inference:
reasoning_effort: high # [MODIFIABLE] Enables reasoning mode; options: low/medium/high or null to disable
max_new_tokens: 200 # [MODIFIABLE] Maximum tokens to generate
top_k: 50 # [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**: Wird `reasoning_effort` nur gesetzt, 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 |
**Wann soll das Denken aktiviert werden**
**Verwenden Sie den Argumentationsmodus (`low`,`medium`, 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 (Parameter auslassen)** 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
# Starten eines Bewertungsjobs
Im Folgenden finden Sie einen Vorschlag für die Konfiguration des Bewertungs-Instance-Typs und des Modelltyps:
```
# Install Dependencies (Helm - https://helm.sh/docs/intro/install/)
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
rm -f ./get_helm.sh
# Install the SageMaker HyperPod CLI
git clone --recurse-submodules https://github.com/aws/sagemaker-hyperpod-cli.git
git checkout -b release_v2
cd sagemaker-hyperpod-cli
pip install .
# Verify the installation
hyperpod --help
# Connect to a SageMaker HyperPod Cluster
hyperpod connect-cluster --cluster-name cluster-name
# Submit the Job using the recipe for eval
# Namespace by default should be kubeflow
hyperpod start-job [--namespace namespace] --recipe evaluation/nova/nova_micro_p5_48xl_general_text_benchmark_eval --override-parameters \
'{
"instance_type":"p5d.48xlarge",
"container": "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-evaluation-repo:SM-HP-Eval-V2-latest",
"recipes.run.name": custom-run-name,
"recipes.run.model_type": model_type,
"recipes.run.model_name_or_path" " model name or finetune checkpoint s3uri,
"recipes.run.data_s3_path": s3 for input data only for genqa and llm_judge, must be full S3 path that include filename,
}'
# List jobs
hyperpod list-jobs [--namespace namespace] [--all-namespaces]
# Getting Job details
hyperpod get-job --job-name job-name [--namespace namespace] [--verbose]
# Listing Pods
hyperpod list-pods --job-name job-name --namespace namespace
# Cancel Job
hyperpod cancel-job --job-name job-name [--namespace namespace]
```
Sie sollten den Jobstatus auch über die Konsole des Amazon-EKS-Clusters einsehen können.
# Zugriff auf und Analyse der Bewertungsergebnisse
Nachdem Ihr Bewertungsjob erfolgreich abgeschlossen wurde, können Sie mithilfe der Informationen in diesem Abschnitt auf die Ergebnisse zugreifen und sie analysieren. Basierend auf dem im Rezept definierten `output_s3_path` (wie `s3://output_path/`) sieht die Ausgabestruktur wie folgt aus:
```
job_name/
├── eval-result/
│ └── results_[timestamp].json
│ └── inference_output.jsonl (only present for gen_qa)
│ └── details/
│ └── model/
│ └── execution-date-time/
│ └──details_task_name_#_datetime.parquet
└── tensorboard-results/
└── eval/
└── events.out.tfevents.[timestamp]
```
Die Metrikergebnisse werden am angegebenen S3-Ausgabespeicherort `s3://output_path/job_name/eval-result/result-timestamp.json` gespeichert.
Tensorboard-Ergebnisse werden im S3-Pfad `s3://output_path/job_name/eval-tensorboard-result/eval/event.out.tfevents.epoch+ip` gespeichert.
Alle Inferenzausgaben, mit Ausnahme von `llm_judge` und `strong_reject`, werden im S3-Pfad gespeichert: `s3://output_path/job_name/eval-result/details/model/taskname.parquet`.
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
Führen Sie die folgenden Schritte aus, um Ihre Bewertungskennzahlen in Tensorboard zu visualisieren:
1. Navigieren Sie zu SageMaker AI Tensorboard.
1. Wählen Sie **S3-Ordner** aus.
1. Fügen Sie Ihren S3-Ordnerpfad hinzu, z. B. `s3://output_path/job-name/eval-tensorboard-result/eval`.
1. Warten Sie, bis die Synchronisation abgeschlossen ist.
Die Zeitreihen, Skalare und Textvisualisierungen sind verfügbar.
Wir empfehlen Ihnen, die folgenden bewährten Methoden:
+ 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 ein erfolgreiches Laden der Daten zu gewährleisten.
Sie finden SageMaker HyperPod Auftragsfehlerprotokolle in der CloudWatch Protokollgruppe`/aws/sagemaker/Clusters/cluster-id`.
## Ausgabeformat für Log Probability
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`
# RFT-Bewertung
**Anmerkung**
Die Bewertung über Remote-Prämienfunktionen in Ihrer eigenen AWS Umgebung ist nur verfügbar, wenn Sie Kunde von Amazon Nova Forge sind.
**Wichtig**
Das `rl_env` Konfigurationsfeld wird ausschließlich zur Evaluierung verwendet, nicht für Schulungen. Während des Trainings konfigurieren Sie Belohnungsfunktionen mithilfe einer `reward_lambda_arn` (Single-Turn) oder einer BYOO-Infrastruktur mit `rollout.delegate: true` (Multi-Turn).
**Was ist RFT-Evaluierung?**
Mit der RFT-Evaluierung können Sie die Leistung Ihres Modells mithilfe benutzerdefinierter Belohnungsfunktionen vor, während oder nach dem Reinforcement-Learning-Training bewerten. Im Gegensatz zu Standardbewertungen, die vordefinierte Metriken verwenden, können Sie mit RFT Evaluation Ihre eigenen Erfolgskriterien mithilfe einer Lambda-Funktion definieren, die Modellergebnisse auf der Grundlage Ihrer spezifischen Anforderungen bewertet.
**Warum mit RFT evaluieren?**
Die Bewertung ist entscheidend, um festzustellen, ob der RL-Feinabstimmungsprozess Folgendes beinhaltet:
+ Verbesserte Abstimmung des Modells auf Ihren spezifischen Anwendungsfall und Ihre menschlichen Werte
+ Beibehaltung oder Verbesserung der Modellfunktionen bei wichtigen Aufgaben
+ Vermeidung unbeabsichtigter Nebenwirkungen wie verringerte Sachlichkeit, erhöhte Ausführlichkeit oder Leistungseinbußen bei anderen Aufgaben
+ Hat Ihre benutzerdefinierten Erfolgskriterien erfüllt, wie sie in Ihrer Belohnungsfunktion definiert sind
**Wann sollte die RFT-Evaluierung verwendet werden**
Verwenden Sie RFT Evaluation in diesen Szenarien:
+ Vor dem RFT-Training: Legen Sie Basiskennzahlen für Ihren Bewertungsdatensatz fest
+ Während des RFT-Trainings: Überwachen Sie den Trainingsfortschritt mit Zwischenstationen
+ Nach dem RFT-Training: Stellen Sie sicher, dass das endgültige Modell Ihren Anforderungen entspricht
+ Modelle vergleichen: Evaluieren Sie mehrere Modellversionen anhand einheitlicher Prämienkriterien
**Anmerkung**
Verwenden Sie RFT Evaluation, wenn Sie benutzerdefinierte, domänenspezifische Metriken benötigen. Verwenden Sie für allgemeine Bewertungsmethoden (Genauigkeit, Verwirrung, BLEU) die Standardauswertungsmethoden.
**Topics**
+ [Datenformatanforderungen](#nova-hp-evaluate-rft-data-format)
+ [Vorbereitung Ihres Bewertungsrezepts](#nova-hp-evaluate-rft-recipe)
+ [Voreingestellte Belohnungsfunktionen](#nova-hp-evaluate-rft-preset)
+ [Erstellen Sie Ihre Belohnungsfunktion](#nova-hp-evaluate-rft-create-function)
+ [IAM-Berechtigungen](#nova-hp-evaluate-rft-iam)
+ [Ausführung des Evaluierungsjobs](#nova-hp-evaluate-rft-execution)
+ [Evaluierungsergebnisse verstehen](#nova-hp-evaluate-rft-results)
## Datenformatanforderungen
**Struktur der Eingabedaten**
Die Eingabedaten der RFT-Bewertung müssen dem OpenAI Reinforcement Fine-Tuning-Format entsprechen. Jedes Beispiel ist ein JSON-Objekt, das Folgendes enthält:
+ `messages`: Eine Reihe von Konversationswechseln mit `system` und Rollen `user`
+ Optionale weitere Metadaten, z. B. reference\$1answer
**Beispiel für ein Datenformat**
Das folgende Beispiel zeigt das erforderliche Format:
```
{
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Solve for x. Return only JSON like {\"x\": }. Equation: 2x + 5 = 13"
}
]
}
],
"reference_answer": {
"x": 4
}
}
```
**Derzeitige Einschränkungen**
Die folgenden Einschränkungen gelten für die RFT-Evaluierung:
+ Nur Text: Es werden keine multimodalen Eingaben (Bilder, Audio, Video) unterstützt
+ Single-Turn-Konversationen: Unterstützt nur Einzelbenutzernachrichten (keine Multi-Turn-Dialoge)
+ JSON-Format: Die Eingabedaten müssen im JSONL-Format vorliegen (ein JSON-Objekt pro Zeile)
+ Modellausgaben: Die Auswertung erfolgt anhand der generierten Vervollständigungen aus dem angegebenen Modell
## Vorbereitung Ihres Bewertungsrezepts
**Beispiel für eine Rezeptkonfiguration**
Das folgende Beispiel zeigt ein vollständiges RFT-Evaluierungsrezept:
```
run:
name: nova-lite-rft-eval-job
model_type: amazon.nova-lite-v1:0:300k
model_name_or_path: s3://escrow_bucket/model_location # [MODIFIABLE] S3 path to your model or model identifier
replicas: 1 # [MODIFIABLE] For SageMaker Training jobs only; fixed for SageMaker HyperPod jobs
data_s3_path: "" # [REQUIRED FOR HYPERPOD] Leave empty for SageMaker Training jobs
output_s3_path: "" # [REQUIRED] Output artifact S3 path for evaluation results
evaluation:
task: rft_eval # [FIXED] Do not modify
strategy: rft_eval # [FIXED] Do not modify
metric: all # [FIXED] Do not modify
# Inference Configuration
inference:
max_new_tokens: 8196 # [MODIFIABLE] Maximum tokens to generate
top_k: -1 # [MODIFIABLE] Top-k sampling parameter
top_p: 1.0 # [MODIFIABLE] Nucleus sampling parameter
temperature: 0 # [MODIFIABLE] Sampling temperature (0 = deterministic)
top_logprobs: 0
# Evaluation Environment Configuration (NOT used in training)
rl_env:
reward_lambda_arn: arn:aws:lambda:::function:
```
## Voreingestellte Belohnungsfunktionen
Zwei voreingestellte Belohnungsfunktionen (`prime_code`und`prime_math`) sind als Lambda-Schicht für eine einfache Integration in Ihre RFT-Lambda-Funktionen verfügbar.
**-Übersicht**
Diese voreingestellten Funktionen bieten out-of-the-box Evaluierungsfunktionen für:
+ **prime\$1code: Codegenerierung** und Korrektheitsbewertung
+ **prime\$1math**: Mathematisches Denken und Bewertung der Problemlösung
**Quick Setup**
Um voreingestellte Belohnungsfunktionen zu verwenden:
1. [Laden Sie die Lambda-Schicht aus den nova-custom-eval-sdk Versionen herunter](https://github.com/aws/nova-custom-eval-sdk/releases)
1. Veröffentlichen Sie die Lambda-Schicht mit AWS CLI:
```
aws lambda publish-layer-version \
--layer-name preset-function-layer \
--description "Preset reward function layer with dependencies" \
--zip-file fileb://universal_reward_layer.zip \
--compatible-runtimes python3.9 python3.10 python3.11 python3.12 \
--compatible-architectures x86_64 arm64
```
1. Fügen Sie die Ebene zu Ihrer Lambda-Funktion in der AWS Konsole hinzu (Wählen Sie die Ebene preset-function-layer aus der benutzerdefinierten Ebene aus und fügen Sie AWSSDKPandas-Python 312 für numpy-Abhängigkeiten hinzu)
1. Importieren und in Ihrem Lambda-Code verwenden:
```
from prime_code import compute_score # For code evaluation
from prime_math import compute_score # For math evaluation
```
**prime\$1code-Funktion**
**Zweck**: Evaluiert Aufgaben zur Python-Codegenerierung, indem Code anhand von Testfällen ausgeführt und die Richtigkeit gemessen wird.
**Beispiel für ein Eingabedatensatzformat aus der Auswertung**:
```
{"messages":[{"role":"user","content":"Write a function that returns the sum of two numbers."}],"reference_answer":{"inputs":["3\n5","10\n-2","0\n0"],"outputs":["8","8","0"]}}
{"messages":[{"role":"user","content":"Write a function to check if a number is even."}],"reference_answer":{"inputs":["4","7","0","-2"],"outputs":["True","False","True","True"]}}
```
**Hauptmerkmale**:
+ Automatische Codeextraktion aus Markdown-Codeblöcken
+ Funktionserkennung und anrufbasiertes Testen
+ Ausführung von Testfällen mit Timeout-Schutz
+ Syntaxvalidierung und Kompilierungsprüfungen
+ Detaillierte Fehlerberichterstattung mit Tracebacks
**prime\$1math-Funktion**
**Zweck**: Evaluiert die Fähigkeiten zum mathematischen Denken und zur Problemlösung mit Unterstützung symbolischer Mathematik.
Eingabeformat**:**
```
{"messages":[{"role":"user","content":"What is the derivative of x^2 + 3x?."}],"reference_answer":"2*x + 3"}
```
**Die wichtigsten Funktionen**:
+ Symbolische mathematische Bewertung mit SymPy
+ Mehrere Antwortformate (LaTeX, Klartext, symbolisch)
+ Mathematische Äquivalenzprüfung
+ Normalisierung und Vereinfachung von Ausdrücken
**Best Practices**
Folgen Sie diesen bewährten Methoden, wenn Sie voreingestellte Belohnungsfunktionen verwenden:
+ Verwenden Sie in Testfällen die richtigen Datentypen (Ganzzahlen im Vergleich zu Zeichenketten, boolesche Werte im Vergleich zu „True“)
+ Stellen Sie bei Codeproblemen klare Funktionssignaturen bereit
+ Schließen Sie Grenzfälle in Testeingaben ein (Null, negative Zahlen, leere Eingaben)
+ Formatieren Sie mathematische Ausdrücke konsistent in Referenzantworten
+ Testen Sie Ihre Belohnungsfunktion vor der Bereitstellung mit Beispieldaten
## Erstellen Sie Ihre Belohnungsfunktion
**Lambda-ARN**
Sie müssen sich für den Lambda-ARN auf das folgende Format beziehen:
```
"arn:aws:lambda:*:*:function:*SageMaker*"
```
Wenn das Lambda dieses Benennungsschema nicht hat, schlägt der Job mit dem folgenden Fehler fehl:
```
[ERROR] Unexpected error: lambda_arn must contain one of: ['SageMaker', 'sagemaker', 'Sagemaker'] when running on SMHP platform (Key: lambda_arn)
```
**Struktur der Lambda-Funktion**
Ihre Lambda-Funktion empfängt Stapel von Modellausgaben und gibt Prämienwerte zurück. Im Folgenden finden Sie ein Beispiel für eine Implementierung:
```
from typing import List, Any
import json
import re
from dataclasses import asdict, dataclass
@dataclass
class MetricResult:
"""Individual metric result."""
name: str
value: float
type: str
@dataclass
class RewardOutput:
"""Reward service output."""
id: str
aggregate_reward_score: float
metrics_list: List[MetricResult]
def lambda_handler(event, context):
""" Main lambda handler """
return lambda_grader(event)
def lambda_grader(samples: list[dict]) -> list[dict]:
""" Core grader function """
scores: List[RewardOutput] = []
for sample in samples:
print("Sample: ", json.dumps(sample, indent=2))
# Extract components
idx = sample.get("id", "no id")
if not idx or idx == "no id":
print(f"ID is None/empty for sample: {sample}")
ground_truth = sample.get("reference_answer")
if "messages" not in sample:
print(f"Messages is None/empty for id: {idx}")
continue
if ground_truth is None:
print(f"No answer found in ground truth for id: {idx}")
continue
# Get model's response (last turn is assistant turn)
last_message = sample["messages"][-1]
if last_message["role"] != "nova_assistant":
print(f"Last message is not from assistant for id: {idx}")
continue
if "content" not in last_message:
print(f"Completion text is empty for id: {idx}")
continue
model_text = last_message["content"]
# --- Actual scoring logic (lexical overlap) ---
ground_truth_text = _extract_ground_truth_text(ground_truth)
# Calculate main score and individual metrics
overlap_score = _lexical_overlap_score(model_text, ground_truth_text)
# Create two separate metrics as in the first implementation
accuracy_score = overlap_score # Use overlap as accuracy
fluency_score = _calculate_fluency(model_text) # New function for fluency
# Create individual metrics
metrics_list = [
MetricResult(name="accuracy", value=accuracy_score, type="Metric"),
MetricResult(name="fluency", value=fluency_score, type="Reward")
]
ro = RewardOutput(
id=idx,
aggregate_reward_score=overlap_score,
metrics_list=metrics_list
)
print(f"Response for id: {idx} is {ro}")
scores.append(ro)
# Convert to dict format
result = []
for score in scores:
result.append({
"id": score.id,
"aggregate_reward_score": score.aggregate_reward_score,
"metrics_list": [asdict(metric) for metric in score.metrics_list]
})
return result
def _extract_ground_truth_text(ground_truth: Any) -> str:
"""
Turn the `ground_truth` field into a plain string.
"""
if isinstance(ground_truth, str):
return ground_truth
if isinstance(ground_truth, dict):
# Common patterns: { "explanation": "...", "answer": "..." }
if "explanation" in ground_truth and isinstance(ground_truth["explanation"], str):
return ground_truth["explanation"]
if "answer" in ground_truth and isinstance(ground_truth["answer"], str):
return ground_truth["answer"]
# Fallback: stringify the whole dict
return json.dumps(ground_truth, ensure_ascii=False)
# Fallback: stringify anything else
return str(ground_truth)
def _tokenize(text: str) -> List[str]:
# Very simple tokenizer: lowercase + alphanumeric word chunks
return re.findall(r"\w+", text.lower())
def _lexical_overlap_score(model_text: str, ground_truth_text: str) -> float:
"""
Simple lexical overlap score in [0, 1]:
score = |tokens(model) ∩ tokens(gt)| / |tokens(gt)|
"""
gt_tokens = _tokenize(ground_truth_text)
model_tokens = _tokenize(model_text)
if not gt_tokens:
return 0.0
gt_set = set(gt_tokens)
model_set = set(model_tokens)
common = gt_set & model_set
return len(common) / len(gt_set)
def _calculate_fluency(text: str) -> float:
"""
Calculate a simple fluency score based on:
- Average word length
- Text length
- Sentence structure
Returns a score between 0 and 1.
"""
# Simple implementation - could be enhanced with more sophisticated NLP
words = _tokenize(text)
if not words:
return 0.0
# Average word length normalized to [0,1] range
# Assumption: average English word is ~5 chars, so normalize around that
avg_word_len = sum(len(word) for word in words) / len(words)
word_len_score = min(avg_word_len / 10, 1.0)
# Text length score - favor reasonable length responses
ideal_length = 100 # words
length_score = min(len(words) / ideal_length, 1.0)
# Simple sentence structure check (periods, question marks, etc.)
sentence_count = len(re.findall(r'[.!?]+', text)) + 1
sentence_ratio = min(sentence_count / (len(words) / 15), 1.0)
# Combine scores
fluency_score = (word_len_score + length_score + sentence_ratio) / 3
return fluency_score
```
**Lambda-Anforderungsformat**
Ihre Lambda-Funktion empfängt Daten in diesem Format:
```
[
{
"id": "sample-001",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Do you have a dedicated security team?"
}
]
},
{
"role": "nova_assistant",
"content": [
{
"type": "text",
"text": "As an AI developed by Company, I don't have a dedicated security team in the traditional sense. However, the development and deployment of AI systems like me involve extensive security measures, including data encryption, user privacy protection, and other safeguards to ensure safe and responsible use."
}
]
}
],
"reference_answer": {
"compliant": "No",
"explanation": "As an AI developed by Company, I do not have a traditional security team. However, the deployment involves stringent safety measures, such as encryption and privacy safeguards."
}
}
]
```
**Anmerkung**
Die Nachrichtenstruktur umfasst das verschachtelte `content` Array, das dem Eingabedatenformat entspricht. Die letzte Nachricht mit Rolle `nova_assistant` enthält die vom Modell generierte Antwort.
**Lambda-Antwortformat**
Ihre Lambda-Funktion muss Daten in diesem Format zurückgeben:
```
[
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
]
```
**Antwortfelder**:
+ `id`: Muss mit der eingegebenen Proben-ID übereinstimmen
+ `aggregate_reward_score`: Gesamtpunktzahl (normalerweise 0,0 bis 1,0)
+ `metrics_list`: Array einzelner Metriken mit:
+ `name`: Kennzahl der Metrik (z. B. „Genauigkeit“, „Fließfähigkeit“)
+ `value`: Metrischer Wert (typischerweise 0,0 bis 1,0)
+ `type`: Entweder „Metrik“ (für Berichte) oder „Belohnung“ (wird in Schulungen verwendet)
## IAM-Berechtigungen
**Erforderliche Berechtigungen**
Ihre SageMaker KI-Ausführungsrolle muss über Berechtigungen zum Aufrufen Ihrer Lambda-Funktion verfügen. Fügen Sie diese Richtlinie zu Ihrer SageMaker KI-Ausführungsrolle hinzu:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
**Lambda-Ausführungsrolle**
Die Ausführungsrolle Ihrer Lambda-Funktion benötigt grundlegende Lambda-Ausführungsberechtigungen:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
}
]
}
```
**Zusätzliche Berechtigungen**: Wenn Ihre Lambda-Funktion auf andere AWS Dienste zugreift (z. B. Amazon S3 für Referenzdaten, DynamoDB für die Protokollierung), fügen Sie diese Berechtigungen der Lambda-Ausführungsrolle hinzu.
## Ausführung des Evaluierungsjobs
1. **Bereiten Sie Ihre Daten vor**
+ Formatieren Sie Ihre Bewertungsdaten gemäß den Anforderungen an das Datenformat
+ Laden Sie Ihre JSONL-Datei auf Amazon S3 hoch: `s3://your-bucket/eval-data/eval_data.jsonl`
1. **Konfiguriere dein Rezept**
Aktualisieren Sie das Beispielrezept mit Ihrer Konfiguration:
+ Stellen Sie `model_name_or_path` den Standort Ihres Modells ein
+ Stellen `lambda_arn` Sie Ihre Belohnungsfunktion ARN ein
+ Stellen `output_s3_path` Sie den gewünschten Ausgabeort ein
+ Passen Sie die `inference` Parameter nach Bedarf an
Speichern Sie das Rezept unter `rft_eval_recipe.yaml`
1. **Führen Sie die Evaluierung aus**
Führen Sie den Evaluierungsjob mit dem mitgelieferten Notizbuch aus: [Evaluationsnotizbuch für das Nova-Modell](https://docs.aws.amazon.com/sagemaker/latest/dg/nova-model-evaluation.html#nova-model-evaluation-notebook)
1. **Überwachen Sie den Fortschritt**
Überwachen Sie Ihre Bewertungsaufgabe durch:
+ SageMaker KI-Konsole: Überprüfen Sie den Auftragsstatus und die Protokolle
+ CloudWatch Protokolle: Detaillierte Ausführungsprotokolle anzeigen
+ Lambda Logs: Probleme mit der Belohnungsfunktion debuggen
## Evaluierungsergebnisse verstehen
**Ausgabeformat**
Der Evaluierungsjob gibt die Ergebnisse im JSONL-Format an Ihrem angegebenen Amazon S3 S3-Standort aus. Jede Zeile enthält die Bewertungsergebnisse für eine Probe:
```
{
"id": "sample-001",
"aggregate_reward_score": 0.75,
"metrics_list": [
{
"name": "accuracy",
"value": 0.85,
"type": "Metric"
},
{
"name": "fluency",
"value": 0.90,
"type": "Reward"
}
]
}
```
**Anmerkung**
Die Ausgabe des RFT-Evaluierungsjobs ist identisch mit dem Lambda Response-Format. Der Bewertungsservice durchläuft die Antwort Ihrer Lambda-Funktion unverändert und gewährleistet so die Konsistenz zwischen Ihren Belohnungsberechnungen und den Endergebnissen.
**Interpretation der Ergebnisse**
**Gesamter Prämienwert**:
+ Bereich: Normalerweise 0,0 (am schlechtesten) bis 1,0 (am besten), hängt jedoch von Ihrer Implementierung ab
+ Zweck: Eine einzelne Zahl, die die Gesamtleistung zusammenfasst
+ Verwendungszweck: Modelle vergleichen, Verbesserungen im Vergleich zu Schulungen verfolgen
**Individuelle Metriken**:
+ Metriktyp: Informationsmetriken für die Analyse
+ Art der Belohnung: Metriken, die während des RFT-Trainings verwendet wurden
+ Interpretation: Höhere Werte bedeuten im Allgemeinen eine bessere Leistung (es sei denn, Sie entwerfen inverse Metriken)
**Leistungs-Benchmarks**
Was unter „guter“ Leistung zu verstehen ist, hängt von Ihrem Anwendungsfall ab:
| Punktebereich | Interpretation | Action |
| --- |--- |--- |
| 0,8 - 1,0 | Ausgezeichnet | Modell bereit für den Einsatz |
| 0,6 - 0,8 | Gut | Geringfügige Verbesserungen können von Vorteil sein |
| 0,4 - 0,6 | Fair | Signifikante Verbesserung erforderlich |
| 0,0 - 0,4 | Schlecht | Überprüfen Sie die Trainingsdaten und die Belohnungsfunktion |
**Wichtig**
Dies sind allgemeine Richtlinien. Definieren Sie Ihre eigenen Schwellenwerte auf der Grundlage der Geschäftsanforderungen, der Leistung des Basismodells, der domänenspezifischen Einschränkungen und der Kosten-Nutzen-Analyse von Weiterbildungsmaßnahmen.
# HyperPod Überwachung von Aufträgen mit MLflow
Sie können MLflow es verwenden, um Ihre Trainingsjobs auf zu verfolgen und zu überwachen SageMaker HyperPod. Folgen Sie diesen Schritten, um es einzurichten MLflow und mit Ihren Trainingsrezepten zu verbinden.
***Erstelle die MLflow App***
Beispiel für einen AWS CLI Befehl
```
aws sagemaker-mlflow create-mlflow-app \
--name \
--artifact-store-uri \
--role-arn \
--region
```
Beispielausgabe
```
{
"Arn": "arn:aws:sagemaker:us-east-1:111122223333:mlflow-app/app-LGZEOZ2UY4NZ"
}
```
***Generieren Sie eine vorsignierte URL***
Beispiel für AWS CLI einen Befehl
```
aws sagemaker-mlflow create-presigned-mlflow-app-url \
--arn \
--region \
--output text
```
Beispielausgabe
```
https://app-LGZEOZ2UY4NZ.mlflow.sagemaker.us-east-1.app.aws/auth?authToken=eyJhbGciOiJIUzI1NiJ9.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.HNvZOfqft4m7pUS52MlDwoi1BA8Vsj3cOfa_CvlT4uw
```
***Öffnen Sie die vorsignierte URL und sehen Sie sich die App an***
Klick
```
https://app-LGZEOZ2UY4NZ.mlflow.sagemaker.us-east-1.app.aws/auth?authToken=eyJhbGciOiJIUzI1NiJ9.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.HNvZOfqft4m7pUS52MlDwoi1BA8Vsj3cOfa_CvlT4uw
```
Anzeigen
![\[Beispiel für ein Amazon Nova-Bild.\]](http://docs.aws.amazon.com/de_de/nova/latest/nova2-userguide/images/screenshot-nova-model-1.png)
***Gehen Sie zum Rezept unter dem Ausführungsblock Ihres SageMaker HyperPod Rezepts***
Rezept
```
run
mlflow_tracking_uri: arn:aws:sagemaker:us-east-1:111122223333:mlflow-app/app-LGZEOZ2UY4NZ
```
Anzeigen
![\[Beispiel für ein Amazon Nova-Bild.\]](http://docs.aws.amazon.com/de_de/nova/latest/nova2-userguide/images/screenshot-nova-model-2.png)