

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.

# Feinabstimmung von Amazon Nova-Modellen mit Verstärkungs-Feinabstimmung
<a name="rft-nova-models"></a>

Stellen Sie vor der Feinabstimmung sicher, dass Sie über die Voraussetzungen verfügen, da Amazon Bedrock spezielle Berechtigungen benötigt, um den Feinabstimmungsprozess zu erstellen und zu verwalten. Umfassende Informationen zu Sicherheit und Berechtigungen finden Sie unter. [Zugriff und Sicherheit für Amazon Nova-Modelle](rft-access-security.md)

Führen Sie die Feinabstimmung der Verstärkung für Amazon Nova-Modelle in 5 Schritten durch:

1. **Trainingsdatensatz bereitstellen** — Laden Sie Eingabeaufforderungen im erforderlichen Format (z. B. JSONL) als Trainingsdatensatz für die Feinabstimmung von Verstärkungen hoch. Weitere Informationen finden Sie unter [Daten für Amazon Nova-Modelle vorbereiten](rft-prepare-data.md).

1. **Belohnungsfunktion konfigurieren (Grader)** — Definieren Sie einen Grader, der die Antworten des Modells anhand von Korrektheit, Struktur, Tonalität oder anderen Zielen bewertet. Die Belohnungsfunktion kann mit Lambda ausgeführt werden, um Zielwerte zu berechnen. Sie können auch ein Modell als Richter auswählen (über die Konsole) und Antworten anhand von Kriterien und Prinzipien bewerten, die Sie konfigurieren (die Konsole wandelt diese automatisch in Lambda-Funktionen um). Weitere Informationen finden Sie unter [Prämienfunktionen für Amazon Nova-Modelle einrichten](reward-functions.md).

1. **Job zur Feinabstimmung der Bewehrung einreichen** — Starten Sie den Auftrag zur Feinabstimmung der Bewehrung, indem Sie das Basismodell, den Datensatz, die Belohnungsfunktion und andere optionale Einstellungen wie Hyperparameter angeben. Weitere Informationen finden Sie unter [Feinabstimmungsaufträge für Amazon Nova-Modelle erstellen und verwalten](rft-submit-job.md).

1. **Schulung überwachen** — Verfolgen Sie den Jobstatus, die Vergütungskennzahlen und den Trainingsfortschritt bis zum Abschluss. Weitere Informationen finden Sie unter [Überwachen Sie Ihren RFT-Trainingsjob](rft-submit-job.md#rft-monitor-job).

1. Fein **abgestimmtes Modell verwenden** — Stellen Sie nach Abschluss des Auftrags das resultierende RFT-Modell mit einem Klick bereit, um bei Bedarf Inferenzen zu erhalten. Sie können Provisioned Throughput auch für unternehmenskritische Workloads verwenden, die eine konsistente Leistung erfordern. Siehe [Einrichten von Inferenz für ein benutzerdefiniertes Modell](model-customization-use.md). Verwenden Sie **Test in Playground**, um die Antworten zu bewerten und mit dem Basismodell zu vergleichen.

**Wichtig**  
Sie können Amazon Bedrock maximal 20.000 Eingabeaufforderungen zur Feinabstimmung des Modells zur Verstärkung senden.

## Unterstützte Nova-Modelle
<a name="rft-nova-supported-models"></a>

Die folgende Tabelle zeigt die Amazon Nova-Modelle, die Sie mit der Feinabstimmung der Verstärkung anpassen können:

**Anmerkung**  
Informationen zu weiteren unterstützten Modellen, einschließlich Modellen mit offenem Gewicht, finden Sie unter. [Feinabstimmung von Modellen mit offenem Gewicht mithilfe von -compatible OpenAI APIs](fine-tuning-openai-apis.md)


**Unterstützte Modelle für die Feinabstimmung von Verstärkungen**  

| Anbieter | Modell | Modell-ID | Unterstützung von Modellen für einzelne Regionen | 
| --- | --- | --- | --- | 
| Amazon | Nova 2 Lite | amazon.nova-2-lite-v 1:0:256 k | us-east-1 | 

# Zugriff und Sicherheit für Amazon Nova-Modelle
<a name="rft-access-security"></a>

Bevor Sie mit der Feinabstimmung der Verstärkung beginnen, stellen Sie sicher, dass Sie wissen, welche Art von Zugriff Amazon Bedrock für RFT-spezifische Operationen benötigt. RFT benötigt aufgrund seiner Funktionen zur Ausführung von Prämienfunktionen zusätzliche Berechtigungen, die über die standardmäßige Feinabstimmung hinausgehen.

Informationen zur grundlegenden Sicherheitseinrichtung für die Modellanpassung, einschließlich Vertrauensbeziehungen, Amazon S3 S3-Berechtigungen und KMS-Verschlüsselung, finden Sie unter[Erstellen einer IAM-Servicerolle für die Modellanpassung](custom-model-job-access-security.md#custom-model-job-service-role).

## Voraussetzungen
<a name="rft-access-prerequisites"></a>

Bevor Sie RFT-spezifische IAM-Berechtigungen hinzufügen, müssen Sie die folgenden IAM-Servicerollen hinzufügen:
+ [Vertrauensstellung](custom-model-job-access-security.md#custom-model-job-service-role-trust-relationship)
+ [Berechtigungen zum Zugriff auf Trainings- und Validierungsdateien und zum Schreiben von Ausgabedateien in S3](custom-model-job-access-security.md#custom-model-job-service-role-s3-permissions)

## RFT-spezifische IAM-Berechtigungen
<a name="rft-iam-permissions"></a>

Fügen Sie diese Berechtigungen zu Ihrer bestehenden Servicerolle für Modellanpassungen für RFT-Funktionen hinzu.

### Lambda-Berechtigungen für Belohnungsfunktionen
<a name="rft-lambda-permissions"></a>

Sie müssen Lambda-Aufrufberechtigungen hinzufügen. Im Folgenden finden Sie ein Beispiel für eine Richtlinie, die Sie verwenden können:

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction"
            ],
            "Resource": [
                "arn:aws:lambda:*:*:function:reward-function-name"
            ]
        }
    ]
}
```

### Zugriff auf das Aufruf-Protokoll
<a name="rft-api-log-permissions"></a>

Um bestehende Aufrufprotokolle des Amazon Bedrock-Modells als Trainingsdaten zu verwenden, fügen Sie Berechtigungen für den Zugriff auf Ihren Amazon S3 S3-Bucket hinzu, in dem Aufrufprotokolle gespeichert sind. 

Sie müssen Amazon S3 S3-Bucket-Zugriffsberechtigungen für den Eingabe-Bucket bereitstellen. Im Folgenden finden Sie ein Beispiel für eine Richtlinie, die Sie verwenden können:

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::s3-invocation-logs-bucket",
                "arn:aws:s3:::s3-invocation-logs-bucket/*"
            ]
        }
    ]
}
```

Informationen zur Sicherheitseinrichtung, einschließlich grundlegender IAM-Rollen, Amazon S3 S3-Berechtigungen und Verschlüsselung, finden Sie unter[Erstellen einer IAM-Servicerolle für die Modellanpassung](custom-model-job-access-security.md#custom-model-job-service-role).

## Grader Lambda-Funktionsberechtigungen für RLAIF
<a name="rft-grader-lambda-permissions"></a>

Wenn Sie Ihre eigene Lambda-Funktion für RLAIF-Belohnungsfunktionen (Reinforcement Learning from AI Feedback) erstellen, müssen Sie der Lambda-Ausführungsrolle spezifische Berechtigungen hinzufügen.

### Grundlegende Genehmigungen für LLM-Richter
<a name="rft-bedrock-permissions"></a>

Fügen Sie für LLM-as-Judge Belohnungsfunktionen (RLAIF) Berechtigungen hinzu, um Foundation-Modelle aufzurufen. Im Folgenden finden Sie eine Beispielrichtlinie, die Sie für Ihre Lambda-Ausführungsrolle verwenden können.

**Anmerkung**  
Fügen Sie diese Berechtigungen Ihrer Lambda-Ausführungsrolle nur hinzu, wenn Sie Ihre eigene Lambda-Funktion erstellen. Die Konsole verarbeitet dies automatisch, wenn Lambda-Funktionen über die Konsole erstellt werden.

Im Folgenden finden Sie ein Beispiel für die Berufung von Bedrock LLM als Richter unter Verwendung von Foundation-Modellen:

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel"
            ],
            "Resource": [
                "arn:aws:bedrock:*:*:foundation-model/*"
            ]
        }
    ]
}
```

Im Folgenden finden Sie ein Beispiel für LLM aus dem Grundgestein als Richteraufruf unter Verwendung eines Inferenzprofils:

```
{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel"
            ],
            "Resource": [
                "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-premier-v1:0",
                "arn:aws:bedrock:us-east-2::foundation-model/amazon.nova-premier-v1:0",
                "arn:aws:bedrock:us-west-2::foundation-model/amazon.nova-premier-v1:0"
            ],
            "Condition": {
                "StringLike": {
                    "bedrock:InferenceProfileArn": "arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.amazon.nova-premier-v1:0"
                }
            }
        },
        {
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel"
            ],
            "Resource": [
                "arn:aws:bedrock:us-east-1:111122223333:inference-profile/us.amazon.nova-premier-v1:0"
            ]
        }
    ]
}
```

[Informationen zu den Voraussetzungen für Inferenzprofile finden Sie unter Voraussetzungen für Inferenzprofile.](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-prereq.html)

# Daten für Amazon Nova-Modelle vorbereiten
<a name="rft-prepare-data"></a>

Bei der Feinabstimmung eines Amazon Nova-Modells mit Verstärkungs-Feinabstimmung können Sie Ihre eigenen Eingabeaufforderungen verwenden oder vorhandene Amazon Bedrock API-Aufrufprotokolle als Trainingsdaten verwenden.

## Anforderungen und Quellen für Trainingsdaten
<a name="rft-data-source-options"></a>

Sie können Trainingsdaten über eine der folgenden Optionen bereitstellen:

**Anmerkung**  
Wir unterstützen nur das OpenAI-Chat-Abschlussformat.

### Option 1: Geben Sie Ihre eigenen Eingabeaufforderungen ein
<a name="w2aac15c25c17c15b5b7b1"></a>

Sammeln Sie Ihre Prompts und speichern Sie sie im Dateiformat `.jsonl`. Sie können benutzerdefinierte Datensätze im JSONL-Format hochladen oder vorhandene Datensätze aus Amazon S3 auswählen. Jeder Datensatz in der JSONL muss das OpenAI-Chat-Abschlussformat in der folgenden Struktur verwenden:
+ `messages`: Geben Sie in dieses Feld die Benutzer-, System- oder Assistentenrolle ein, die die für das Modell bereitgestellte Eingabeaufforderung enthält.
+ `reference_answer`: In diesem Feld sollte es die erwarteten Ergebnis- oder Bewertungskriterien enthalten, anhand derer Ihre Belohnungsfunktion die Antwort des Modells bewertet. Es ist nicht auf strukturierte Ergebnisse beschränkt — es kann jedes Format enthalten, das Ihrer Belohnungsfunktion bei der Bewertung der Qualität hilft.
+ [Optional] Sie können Felder hinzufügen, die vom Grader Lambda für die Benotung verwendet werden.

**Voraussetzungen:**
+ JSONL-Format mit Eingabeaufforderungen im OpenAI-Chat-Abschlussformat (eine Aufforderung pro Zeile)
+ Mindestens 100 Datensätze im Trainingsdatensatz
+ Amazon Bedrock validiert automatisch das Format der Trainingsdatensätze

------
#### [ Example: General question-answering ]

```
{
            "messages": [
                {
                    "role": "system", 
                    "content": "You are a helpful assistant"
                },
                {
                    role": "user", 
                    "content": "What is machine learning?"}
            ],
            "reference_answer": "Machine learning is a subset of artificial intelligence that enables computers to learn and make decisions from data without being explicitly programmed."
            }
```

------
#### [ Example: Math problem ]

```
{
  "id": "sample-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"]
  }
}
```

------

### Option 2: Verwenden Sie Aufruf-Logs
<a name="w2aac15c25c17c15b5b7b3"></a>

Wenn Sie einen Auftrag zur Feinabstimmung von Verstärkungen erstellen, können Sie Amazon Bedrock veranlassen, vorhandene Aufrufprotokolle aus Ihrem S3-Bucket als Trainingsdaten zu verwenden. Für Amazon Bedrock ist ein Aufrufprotokoll eine detaillierte Aufzeichnung von Modellaufrufen.

Sie können kundenseitig gespeicherte Invoke/Converse API-Aufrufprotokolle von Amazon S3 für Schulungen verwenden.

**Voraussetzungen:**
+ Die API-Protokollierung muss für Ihre Nutzung von Amazon Bedrock aktiviert sein
+ Protokolle müssen in einem unterstützten Format vorliegen (Amazon Bedrock Invoke/Converse API)
+ Mindestens 100 Beispiele für Eingabeaufforderungen

Um Aufrufprotokolle für die Feinabstimmung der Verstärkung zu verwenden, richten Sie die Modellaufruf-Protokollierung ein, verwenden Sie einen der Modellaufrufvorgänge und stellen Sie sicher, dass Sie einen Amazon S3 S3-Bucket als Ziel für die Protokolle eingerichtet haben. Weitere Informationen zum Einrichten der Aufrufprotokolle finden Sie unter [Überwachen des Modellaufrufs mithilfe von CloudWatch Protokollen und Amazon S3](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html).

Bevor Sie den Verstärkungs-Feintuning-Job mit Aufrufprotokollen aus einem S3-Bucket als Eingabe starten können, müssen Sie Amazon Bedrock-Berechtigungen für den Zugriff auf die Protokolle aus einem S3-Bucket bereitstellen. Weitere Informationen finden Sie unter [Zugriff und Sicherheit bei der Modellanpassung](custom-model-job-access-security.md).

Sie können optional mithilfe eines der Modellaufrufvorgänge Anforderungsmetadaten zu den Prompt-Antwort-Paaren im Aufrufprotokoll hinzufügen und diese dann später zum Filtern der Protokolle verwenden. Amazon Bedrock kann die gefilterten Protokolle zur Feinabstimmung des Modells verwenden.

#### Fügen Sie Anforderungsmetadaten zu Aufforderungen und Antworten in Ihren Aufrufprotokollen hinzu
<a name="rft-request-metadata"></a>

Mithilfe von Aufrufprotokollen können Sie anhand von Anforderungsmetadaten, die den Aufrufprotokollen angehängt sind, die Aufforderungen des Trainingsdatensatzes identifizieren, die Amazon Bedrock für die Feinabstimmung der Verstärkung verwenden soll. 

Im Folgenden finden Sie ein Beispiel für ein Aufrufprotokoll eines Anrufs mit: `InvokeModel` `requestMetadata`

```
{
"schemaType": "ModelInvocationLog",
    "schemaVersion": "1.0",
    "timestamp": "2024-09-11T17:16:18Z",
    "accountId": "XXXXX",
    "identity": {
"arn": "arn:aws:sts::XXXXXXX:assumed-role/Admin/XXXXXX"
    },
    "region": "us-east-1",
    "requestId": "7ee514f3-9eff-467c-af75-8fd564ce58e5",
    "operation": "InvokeModel",
    "modelId": "meta.llama3-1-405b-instruct-v1:0",
    "input": {
"inputContentType": "application/json",
        "inputBodyJson": {
"prompt": "story of two dogs",
            "max_tokens_to_sample": 300
        },
        "inputTokenCount": 13
    },
    "output": {
"outputContentType": "application/json",
        "outputBodyJson": {
"type": "completion",
            "completion": " Here is a story about two dogs:\n\nRex and Charlie were best friends who lived next door to each other. Every morning, their owners would let them out into the backyard to play. Rex was a golden retriever with long, shaggy fur. He loved to run and chase sticks. Charlie was a corgi with short legs and a big smile. He was happy just sniffing the grass and rolling around. \n\nThe two dogs spent every day playing together. Rex would grab a stick and bring it over to Charlie, wagging his tail excitedly. Charlie would take the other end of the stick in his mouth and they'd have a friendly game of tug-of-war. After tiring themselves out, they'd flop down in the warm sunshine for a nap. \n\nAt lunchtime, their owners would call them in for food. Rex would gobble up his kibble hungrily while Charlie ate his at a more leisurely pace. After lunch, it was right back outside for more playtime. The afternoon sunbeams would light up their fur as they chased each other around the yard. \n\nWhen it started getting late, their owners called them in for the night. Rex and Charlie would head inside, tired but happy after another fun day of play. After slurping up fresh water from their bowls, they'd curl up on their beds, Rex's fluffy golden tail tucked over his nose and little",
            "stop_reason": "max_tokens",
            "stop": null
        },
        "outputTokenCount": 300
    },
    "requestMetadata": {
"project": "CustomerService",
        "intent": "ComplaintResolution",
        "priority": "High"
    }
}
```

Sie können das Aufrufprotokoll als Eingabedatenquelle angeben, wenn Sie einen Auftrag zur Feinabstimmung von Verstärkungen starten. Sie können einen Job zur Feinabstimmung von Verstärkungen über die Amazon Bedrock-Konsole starten, indem Sie die API oder das AWS CLI SDK verwenden.

##### Anforderungen für die Bereitstellung von Anforderungsmetadaten
<a name="rft-metadata-requirements"></a>

Die Anforderungsmetadaten müssen die folgenden Anforderungen erfüllen:
+ Sie müssen im JSON-Format für `key:value` bereitgestellt werden.
+ Das Schlüssel/Wert-Paar muss eine Zeichenfolge mit maximal 256 Zeichen sein.
+ Es dürfen maximal 16 Schlüssel/Wert-Paare bereitgestellt werden.

##### Verwenden von Filtern für Anforderungsmetadaten
<a name="rft-metadata-filters"></a>

Sobald Aufrufprotokolle mit Anforderungsmetadaten verfügbar sind, können Sie Filter auf der Grundlage der Anforderungsmetadaten anwenden, um selektiv auszuwählen, welche Eingabeaufforderungen zur Feinabstimmung des Modells aufgenommen werden sollen. Beispielsweise möchten Sie möglicherweise nur solche mit `"project": "CustomerService"` Metadaten und Anforderungsmetadaten einbeziehen. `"priority": "High"`

Um die Protokolle anhand mehrerer Anforderungsmetadaten zu filtern, verwenden Sie einen einzigen booleschen Operator `AND` oder. `OR` Sie können diese Operatoren nicht kombinieren. Verwenden Sie für die Filterung von Metadaten für einzelne Anfragen den `Equals` `Not Equals` Operator oder.

## Merkmale effektiver Trainingsdaten
<a name="rft-data-characteristics"></a>

Effektive RFT-Trainingsdaten erfordern drei Hauptmerkmale:
+ **Klarheit und Konsistenz** — Verwenden Sie klare, eindeutige Eingabeaufforderungen mit einheitlicher Formatierung. Vermeiden Sie widersprüchliche Bezeichnungen, mehrdeutige Anweisungen oder widersprüchliche Referenzantworten, die das Training irreführen könnten.
+ **Vielfalt** — Geben Sie unterschiedliche Eingabeformate, Sonderfälle und Schwierigkeitsgrade an, die die Nutzungsmuster in der Produktion für verschiedene Benutzertypen und Szenarien widerspiegeln.
+ **Effiziente Belohnungsfunktionen** — Entwerfen Sie Funktionen, die schnell (Sekunden, nicht Minuten) ausgeführt werden, parallelisiert werden und konsistente Ergebnisse AWS Lambda liefern, um ein kostengünstiges Training zu ermöglichen.

## Zusätzliche Eigenschaften
<a name="rft-additional-properties"></a>

Das RFT-Datenformat unterstützt benutzerdefinierte Felder, die über die grundlegenden Schemaanforderungen (`messages`und) hinausgehen. `reference_answer` Diese Flexibilität ermöglicht es Ihnen, zusätzliche Daten hinzuzufügen, die Ihre Prämienfunktion für eine korrekte Auswertung benötigt.

**Anmerkung**  
Sie müssen dies nicht in Ihrem Rezept konfigurieren. Das Datenformat unterstützt von Natur aus zusätzliche Felder. Nehmen Sie sie einfach in Ihre JSON-Trainingsdaten auf und sie werden an Ihre Belohnungsfunktion im `metadata` Feld weitergegeben.

**Allgemeine zusätzliche Eigenschaften**
+ `task_id`— Eindeutige Kennung für die Nachverfolgung
+ `difficulty_level`— Indikator für die Komplexität des Problems
+ `domain`— Fachgebiet oder Kategorie
+ `expected_reasoning_steps`— Anzahl der Lösungsschritte

Diese zusätzlichen Felder werden während der Bewertung an Ihre Prämienfunktion übergeben und ermöglichen so eine ausgeklügelte Bewertungslogik, die auf Ihren speziellen Anwendungsfall zugeschnitten ist.

**Beispiele mit zusätzlichen Eigenschaften**

------
#### [ Chemistry problem ]

```
{
  "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
  }
}
```

Das `reference_answer` Feld enthält die erwarteten Ausgabe- oder Bewertungskriterien, anhand derer Ihre Belohnungsfunktion die Antwort des Modells bewertet. Es ist nicht auf strukturierte Ausgaben beschränkt — es kann jedes Format enthalten, das Ihrer Belohnungsfunktion bei der Bewertung der Qualität hilft.

------
#### [ Math problem with metadata ]

```
{
  "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
}
```

------

# Prämienfunktionen für Amazon Nova-Modelle einrichten
<a name="reward-functions"></a>

Belohnungsfunktionen bewerten die Antwortqualität und liefern Feedbacksignale für das Modelltraining. Sie können Prämienfunktionen einrichten, indem Sie benutzerdefinierte Lambda-Funktionen oder von Amazon Bedrock gehostete Foundation-Modelle als Juroren verwenden. Es stehen Vorlagen mit Anleitung zur Verfügung, um die Erstellung von Prämienfunktionen für allgemeine Aufgaben wie die Befolgung von Anweisungen und die Validierung von Formaten zu vereinfachen. Wählen Sie den Ansatz, der Ihren Aufgabenanforderungen entspricht.

## Verstärkendes Lernen durch verifizierbare Prämien (RLVR)
<a name="rft-rlvr"></a>

RLVR optimiert Modelle für objektive Aufgaben wie Codegenerierung oder mathematisches Denken mithilfe überprüfbarer regelbasierter Korrektoren oder Vorlagen. ready-to-use

Sie haben zwei Optionen für RLVR (Benutzerdefinierter Code):

### Option 1: Verwenden Sie von der Konsole bereitgestellte Vorlagen
<a name="w2aac15c25c17c17b5b7b1"></a>

Die Amazon Bedrock-Konsole bietet Beispielvorlagen für Grader-Lambda-Funktionen:
+ Mathematisches Denken mit Überprüfung der Grundwahrheit
+ Formatvalidierung und Überprüfung von Einschränkungen
+ Generische Lambda-Vorlage für Grader mit Boilerplate-Code

Folgen Sie den Anweisungen in der bereitgestellten Vorlage auf der Seite **RFT-Job erstellen** in der [Amazon Bedrock-Konsole](https://console.aws.amazon.com/bedrock).

### Option 2: Bringen Sie Ihre eigene Lambda-Funktion mit
<a name="w2aac15c25c17c17b5b7b3"></a>

Erstellen Sie benutzerdefinierte Belohnungsfunktionen mit Ihrem eigenen Lambda-ARN für komplexe Logik, externe APIs, mehrstufige Berechnungen oder die Kombination mehrerer Bewertungskriterien.

**Anmerkung**  
Wenn Sie Ihre eigene Lambda-Funktion mitbringen, beachten Sie Folgendes:  
Erhöhen Sie das Lambda-Timeout für komplexe Auswertungen von standardmäßig 3 Sekunden auf maximal 15 Minuten.
Die Lambda-Ausführungsrolle benötigt Berechtigungen zum Aufrufen von Modellen, wie unter beschrieben. [Zugriff und Sicherheit für Amazon Nova-Modelle](rft-access-security.md)

## Verstärktes Lernen durch KI-Feedback (RLAIF)
<a name="rft-rlaif"></a>

RLAIF optimiert Modelle für subjektive Aufgaben wie die Befolgung von Anweisungen oder Chatbot-Interaktionen mithilfe von KI-basierten Richtern mit Vorlagen. ready-to-use

**Für RLAIF (Model as Judge):**
+ Wählen Sie ein von Amazon Bedrock gehostetes Basismodell als Judge aus
+ Konfigurieren Sie die Anweisungen für die Evaluierung
+ Definieren Sie Bewertungskriterien und Bewertungsrichtlinien

Verfügbare Vorlagen für LLM-as-Judge Eingabeaufforderungen in der Amazon Bedrock-Konsole:
+ Folgender Unterricht (Schulung im Judge-Modell)
+ Zusammenfassung (Dialoge mit mehreren Turns)
+ Bewertung der Argumentation (CoT für Spezialgebiete)
+ Treue zur RAG (kontextbezogene Fragen und Antworten)

**Anmerkung**  
Die Option **Model as Judge** der Konsole wandelt Ihre Konfiguration während des Trainings automatisch in eine Lambda-Funktion um.

## Einzelheiten zur Implementierung der Lambda-Funktion
<a name="rft-lambda-implementation"></a>

Bei der Implementierung benutzerdefinierter Lambda-Belohnungsfunktionen muss Ihre Funktion Daten im folgenden Format akzeptieren und zurückgeben.

------
#### [ Input structure ]

```
[{
  "id": "123",
  "messages": [
    {
      "role": "user",
      "content": "Do you have a dedicated security team?"
    },
    {
      "role": "assistant",
      "content": "As an AI developed by Amazon, I don not have a dedicated security team..."
    }
  ],
  "metadata": {
    "reference_answer": {
      "compliant": "No",
      "explanation": "As an AI developed by Company, I do not have a traditional security team..."
    },
    "my_key": "sample-001"
  }
}]
```

------
#### [ Output structure ]

```
[{
  "id": "123",
  "aggregate_reward_score": 0.85,
  "metrics_list": [
    {
      "name": "accuracy",
      "value": 0.9,
      "type": "Reward"
    },
    {
      "name": "policy_compliance",
      "value": 0.8,
      "type": "Metric"
    }
  ]
}]
```

------

**Richtlinien für das Design**
+ **Antworten einordnen** — Geben Sie der besten Antwort eine deutlich höhere Punktzahl
+ **Verwenden Sie konsistente Prüfungen** — Beurteilen Sie die Erledigung der Aufgaben, die Einhaltung des Formats, die Sicherheit und die angemessene Dauer
+ **Beibehaltung einer stabilen Skalierung** — Sorgen Sie dafür, dass die Ergebnisse normalisiert werden und nicht ausgenutzt werden können

# Feinabstimmungsaufträge für Amazon Nova-Modelle erstellen und verwalten
<a name="rft-submit-job"></a>

Sie können einen RFT-Job (Reinforcement Fine-Tuning) mithilfe der Amazon Bedrock-Konsole oder API erstellen. Der RFT-Job kann je nach Größe Ihrer Trainingsdaten, Anzahl der Epochen und Komplexität Ihrer Belohnungsfunktionen einige Stunden dauern.

## Voraussetzungen
<a name="rft-prerequisites"></a>
+ Erstellen Sie eine IAM-Servicerolle mit den erforderlichen Berechtigungen. Umfassende Informationen zu Sicherheit und Berechtigungen, einschließlich RFT-spezifischer Berechtigungen, finden Sie unter. [Zugriff und Sicherheit für Amazon Nova-Modelle](rft-access-security.md)
+ (Optional) Verschlüsseln Sie Eingabe- und Ausgabedaten, Ihren RFT-Job oder Inferenzanfragen für benutzerdefinierte Modelle. Weitere Informationen finden Sie unter [Verschlüsselung von benutzerdefinierten Modellen.](https://docs.aws.amazon.com/bedrock/latest/userguide/encryption-custom-job.html)

## Erstellen Sie Ihren RFT-Job
<a name="rft-submit-job-how-to"></a>

Wählen Sie die Registerkarte für Ihre bevorzugte Methode aus und befolgen Sie dann die Schritte:

------
#### [ Console ]

Gehen Sie wie folgt vor, um einen RFT-Job in der Konsole einzureichen:

1. Öffnen Sie die Amazon Bedrock-Konsole und navigieren Sie unter **Tune** zu **Custom Models**.

1. Wählen Sie „**Erstellen**“ und dann „Auftrag zur **Feinabstimmung von Bewehrungen erstellen**“.

1. Wählen Sie im Abschnitt **Modelldetails** **Amazon Nova 2 Lite** als Basismodell aus.

1. Geben Sie im Abschnitt **Anpassungsdetails** den Namen der Anpassung ein.

1. Wählen Sie im Abschnitt **Trainingsdaten** Ihre Datenquelle aus. Wählen Sie entweder aus Ihren verfügbaren Aufrufprotokollen, die in Amazon S3 gespeichert sind, oder wählen Sie den Amazon S3 S3-Speicherort Ihrer Trainingsdatensatz-Datei aus oder laden Sie eine Datei direkt von Ihrem Gerät hoch.
**Anmerkung**  
Ihr Trainingsdatensatz sollte im OpenAI Chat Completions-Datenformat vorliegen. Wenn Sie Aufrufprotokolle im Amazon Bedrock Invoke- oder Converse-Format bereitstellen, konvertiert Amazon Bedrock sie automatisch in das Format Chat Completions.

1. Richten Sie im Bereich **Prämienfunktion Ihren Belohnungsmechanismus** ein:
   + **Model as Judge (RLAIF)** — Wählen Sie ein von Bedrock gehostetes Basismodell als Richter aus und konfigurieren Sie die Anweisungen für die Bewertung. Verwenden Sie dies für subjektive Aufgaben wie die Moderation von Inhalten.
**Anmerkung**  
Die Option **Model as Judge** der Konsole wandelt Ihre Konfiguration während des Trainings automatisch in eine Lambda-Funktion um.
   + **Benutzerdefinierter Code (RLVR)** — Erstellen Sie benutzerdefinierte Belohnungsfunktionen mithilfe von Python-Code, der über Lambda-Funktionen ausgeführt wird. Verwenden Sie dies für objektive Aufgaben wie die Codegenerierung.

   Weitere Informationen finden Sie unter [Prämienfunktionen für Amazon Nova-Modelle einrichten](reward-functions.md).

1. (Optional) Passen Sie im Bereich **Hyperparameter** die Trainingsparameter an oder verwenden Sie Standardwerte.

1. Geben Sie im Abschnitt **Ausgabedaten** den Amazon S3 S3-Speicherort ein, an dem Amazon Bedrock die Jobausgaben speichern soll.

1. Wählen Sie im Abschnitt **Rollenkonfiguration** entweder eine vorhandene Rolle aus der Dropdownliste aus oder geben Sie einen Namen für die zu erstellende Servicerolle ein.

1. (Optional) Konfigurieren Sie im Abschnitt **Zusätzliche Konfiguration** die Validierungsdaten, indem Sie auf einen Amazon S3 S3-Bucket, KMS-Verschlüsselungseinstellungen sowie Job- und Model-Tags verweisen.

1. Wählen Sie „Auftrag zur **Feinabstimmung der Bewehrung erstellen“, um mit dem Auftrag** zu beginnen.

------
#### [ API ]

Senden Sie eine CreateModelCustomizationJob Anfrage mit der `customizationType` Einstellung auf`REINFORCEMENT_FINE_TUNING`.

**Erforderliche Felder:** `roleArn``baseModelIdentifier`,`customModelName`,`jobName`,`trainingDataConfig`,`outputDataConfig`, `rftConfig`

**Beispiel für eine Anfrage:**

```
{
    "roleArn": "arn:aws:iam::123456789012:role/BedrockRFTRole",
    "baseModelIdentifier": "amazon.nova-2.0",
    "customModelName": "my-rft-model",
    "jobName": "my-rft-job",
    "customizationType": "REINFORCEMENT_FINE_TUNING",
    "trainingDataConfig": {
        "s3Uri": "s3://my-bucket/training-data.jsonl"
    },
    "customizationConfig": {
        "rftConfig" : {
            "graderConfig": {
                "lambdaGrader": {
                    "lambdaArn": "arn:aws:lambda:us-east-1:123456789012:function:function-name"
                }
            },
            "hyperParameters": {
                "batchSize": 64,
                "epochCount": 2,
                "evalInterval": 10,
                "inferenceMaxTokens": 8192,
                "learningRate": 0.00001,
                "maxPromptLength": 4096,
                "reasoningEffort": "high",
                "trainingSamplePerPrompt": 4
            }
        }
    },
    "outputDataConfig": {
        "s3Uri": "s3://my-bucket/rft-output/"
    }
}
```

**Python-API-Beispielanfrage:**

```
import boto3

bedrock = boto3.client(service_name='bedrock')
    
# Set parameters
customizationType = "REINFORCEMENT_FINE_TUNING"
baseModelIdentifier = "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-2-lite-v1:0:256k"
roleArn = "${your-customization-role-arn}"
jobName = "MyFineTuningJob"
customModelName = "MyCustomModel"

customizationConfig = {
    'rftConfig' : {
        'graderConfig': {
            'lambdaGrader': {
                'lambdaArn': 'arn:aws:lambda:us-east-1:123456789012:function:function-name'
            }
        },
        'hyperParameters': {
            'batchSize': 64,
            'epochCount': 2,
            'evalInterval': 10,
            'inferenceMaxTokens': 8192,
            'learningRate':0.00001,
            'maxPromptLength': 4096,
            'reasoningEffort': 'high',
            'trainingSamplePerPrompt':4
        }
    }
}

trainingDataConfig = {"s3Uri": "s3://${training-bucket}/myInputData/train.jsonl"}
outputDataConfig = {"s3Uri": "s3://${output-bucket}/myOutputData"}

# Create job
response_ft = bedrock.create_model_customization_job(
    jobName=jobName, 
    customModelName=customModelName,
    roleArn=roleArn,
    baseModelIdentifier=baseModelIdentifier,
    customizationConfig=customizationConfig,
    trainingDataConfig=trainingDataConfig,
    outputDataConfig=outputDataConfig,
    customizationType=customizationType
)

jobArn = response_ft['jobArn']
```

------

## Überwachen Sie Ihren RFT-Trainingsjob
<a name="rft-monitor-job"></a>

Amazon Bedrock bietet Echtzeitüberwachung mit visuellen Grafiken und Metriken während des RFT-Trainings. Diese Kennzahlen helfen Ihnen zu verstehen, ob das Modell richtig konvergiert und ob die Belohnungsfunktion den Lernprozess effektiv steuert.

### Nachverfolgung des Jobstatus
<a name="rft-job-status"></a>

Sie können Ihren RFT-Jobstatus während der Validierungs- und Schulungsphasen in der Amazon Bedrock-Konsole überwachen.

**Indikatoren für den Abschluss:**
+ Der Jobstatus ändert sich zu **Abgeschlossen**, wenn die Schulung erfolgreich abgeschlossen wurde
+ ARN für ein benutzerdefiniertes Modell wird für die Bereitstellung verfügbar
+ Trainingsmetriken erreichen Konvergenzschwellenwerte

### Trainingsmetriken in Echtzeit
<a name="rft-real-time-metrics"></a>

Amazon Bedrock bietet Echtzeitüberwachung während des RFT-Trainings mit visuellen Grafiken, die Trainings- und Validierungsmetriken anzeigen.

#### Wichtigste Trainingsmetriken
<a name="rft-core-metrics"></a>
+ **Trainingsverlust** — Misst, wie gut das Modell aus den Trainingsdaten lernt
+ **Statistik der Trainingsbelohnungen** — Zeigt die von deinen Belohnungsfunktionen zugewiesenen Prämienwerte an
+ **Prämienspanne** — Misst den Unterschied zwischen Prämien mit guten und schlechten Antworten
+ **Genauigkeit bei Trainings- und Validierungssätzen** — Zeigt die Leistung des Modells sowohl bei den Trainings- als auch bei den ausgegebenen Daten

**Detaillierte metrische Kategorien**
+ **Prämienmetriken** — `critic/rewards/mean``critic/rewards/max`, `critic/rewards/min` (Prämienverteilung) und `val-score/rewards/mean@1` (Validierungsprämien)
+ **Modellverhalten** — `actor/entropy` (politische Variation; je höher, desto eher explorativ)
+ **Gesundheit der Ausbildung** — `actor/pg_loss` (Verlust des politischen Gradienten), `actor/pg_clipfrac` (Häufigkeit abgeschnittener Aktualisierungen) und `actor/grad_norm` (Gradientengröße)
+ **Antwortmerkmale** —`prompt_length/mean`,`prompt_length/max`, `prompt_length/min` (Eingabe-Token-Statistiken),, `response_length/mean``response_length/max`, `response_length/min` (Output-Token-Statistiken) und `response/aborted_ratio` (unvollständige Generierungsrate; 0 steht für „Alles abgeschlossen“)
+ **Leistung** — `perf/throughput` (Trainingsdurchsatz), `perf/time_per_step` (Zeit pro Trainingsschritt) und `timing_per_token_ms/*` (Verarbeitungszeiten pro Token)
+ **Ressourcennutzung** —`perf/max_memory_allocated_gb`, `perf/max_memory_reserved_gb` (GPU-Speicher) und `perf/cpu_memory_used_gb` (CPU-Speicher)

#### Visualisierung des Trainingsfortschritts
<a name="rft-progress-visualization"></a>

Die Konsole zeigt interaktive Grafiken an, die im Verlauf Ihres RFT-Jobs in Echtzeit aktualisiert werden. Diese Visualisierungen können Ihnen helfen:
+ Verfolgen Sie die Konvergenz in Richtung optimaler Leistung
+ Identifizieren Sie frühzeitig potenzielle Schulungsprobleme
+ Ermitteln Sie optimale Haltepunkte
+ Vergleichen Sie die Leistung verschiedener Epochen

## Inferenz einrichten
<a name="rft-setup-inference"></a>

Stellen Sie nach Abschluss des Jobs das RFT-Modell für On-Demand-Inferenzen bereit oder verwenden Sie Provisioned Throughput für eine konsistente Leistung. Informationen zum Einrichten von Inferenzen finden Sie unter. [Einrichten von Inferenz für ein benutzerdefiniertes Modell](model-customization-use.md)

Verwenden Sie **Test in Playground**, um die Antworten mit dem Basismodell auszuwerten und zu vergleichen. Informationen zur Bewertung Ihres fertigen RFT-Modells finden Sie unter[Evaluieren Sie Ihr RFT-Modell](rft-evaluate-model.md).