

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.

# Feinabstimmungsaufträge für Amazon Nova-Modelle erstellen und verwalten
Erstellen Sie Aufträge zur Feinabstimmung

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

+ 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


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
Überwachen Sie Ihren RFT-Trainingsjob

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


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


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

#### Wichtigste Trainingsmetriken

+ **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


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


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).