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 Modellen mit offenem Gewicht mithilfe von -compatible OpenAI APIs
Amazon Bedrock bietet OpenAI kompatible API-Endpunkte für die Feinabstimmung von Fundamentmodellen. Mit diesen Endpunkten können Sie vertraute OpenAI SDKs Tools verwenden, um Feinabstimmungsaufträge mit Amazon Bedrock-Modellen zu erstellen, zu überwachen und zu verwalten. Auf dieser Seite wird beschrieben, wie diese APIs für die Feinabstimmung von Verstärkungen verwendet werden.
## Die wichtigsten Funktionen
+ **Trainingsdateien hochladen** — Verwenden Sie die Files-API, um Trainingsdaten hochzuladen und zu verwalten, um Aufgaben zu optimieren
+ **Jobs zur Feinabstimmung erstellen** — Beginne mit der Feinabstimmung von Jobs mit benutzerdefinierten Trainingsdaten und Belohnungsfunktionen
+ Jobs **auflisten und abrufen — Sieh dir alle Jobs** zur Feinabstimmung an und erhalte detaillierte Informationen zu bestimmten Jobs
+ **Auftragsereignisse überwachen** — Verfolgen Sie den Fortschritt der Feinabstimmung anhand detaillierter Ereignisprotokolle
+ **Zugriffs-Checkpoints** — Rufen Sie während des Trainings erstellte Zwischen-Modell-Checkpoints ab
+ **Sofortige Inferenz** — Verwenden Sie nach Abschluss der Feinabstimmung das daraus resultierende fein abgestimmte Modell für On-Demand-Inferenzen über die OpenAI-kompatible API APIs (Responses/Chat Completions API) von Amazon Bedrock ohne zusätzliche Bereitstellungsschritte
+ **Einfache** Migration OpenAI — Kompatibel mit bestehenden SDK-Codebasen
## Verstärkter Arbeitsablauf zur Feinabstimmung bei Modellen mit offenem Gewicht
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. [Zugang und Sicherheit für Modelle mit offenem Gewicht](rft-open-weight-access-security.md)
Führen Sie die Feinabstimmung der Bewehrung für Modelle mit offenem Gewicht in 5 Schritten durch:
1. **Trainingsdatensatz hochladen** — Verwenden Sie die Files-API, um Eingabeaufforderungen im erforderlichen Format (z. B. JSONL) hochzuladen, wobei der Zweck der Feinabstimmung als Trainingsdatensatz zur Feinabstimmung von Verstärkungen dient. Weitere Informationen finden Sie unter [Daten für Modelle mit offenem Gewicht vorbereiten](rft-prepare-data-open-weight.md).
1. **Belohnungsfunktion konfigurieren** — Definieren Sie einen Prüfer, der anhand von Lambda-Funktionen Modellantworten anhand von Korrektheit, Struktur, Tonalität oder anderen Zielen bewertet. Weitere Informationen finden Sie unter [Einrichtung von Belohnungsfunktionen für Modelle mit offenem Gewicht](reward-functions-open-weight.md).
1. **Feinabstimmungsauftrag erstellen** — Starten Sie den Auftrag zur Feinabstimmung der Verstärkung mithilfe der OpenAI -kompatiblen API, indem Sie das Basismodell, den Datensatz, die Belohnungsfunktion und andere optionale Einstellungen wie Hyperparameter angeben. Weitere Informationen finden Sie unter [Erstellen Sie einen Feinabstimmungsauftrag](fine-tuning-openai-job-create.md#fine-tuning-openai-create-job).
1. **Überwachen Sie den Trainingsfortschritt** — Verfolgen Sie den Jobstatus, Ereignisse und Trainingsmetriken mithilfe der Feinabstimmungsjobs. APIs Weitere Informationen finden Sie unter [Führt Feinabstimmungsereignisse auf](fine-tuning-openai-job-create.md#fine-tuning-openai-list-events). Greifen Sie auf Prüfpunkte des Zwischenmodells zu, um die Leistung in verschiedenen Trainingsphasen zu bewerten, siehe. [Listet Checkpoints für die Feinabstimmung auf](fine-tuning-openai-job-create.md#fine-tuning-openai-list-checkpoints)
1. **Inferenz ausführen** — Verwenden Sie die fein abgestimmte Modell-ID direkt für Inferenzen über die mit Amazon Bedrock OpenAI kompatiblen Antworten oder Chat-Abschlüsse. APIs Weitere Informationen finden Sie unter [Führen Sie die Inferenz mit einem fein abgestimmten Modell aus](fine-tuning-openai-job-create.md#fine-tuning-openai-inference).
## Unterstützte Regionen und Endpunkte
Die folgende Tabelle zeigt die Foundation-Modelle und Regionen, die eine OpenAI kompatible Feinabstimmung APIs unterstützen:
**Unterstützte Modelle und Regionen für eine OpenAI kompatible Feinabstimmung APIs**
| Anbieter | Modell | Modell-ID | Name der Region | Region | Endpoint |
| --- | --- | --- | --- | --- | --- |
| OpenAI | GPT-OSS-20b | openai.gpt-oss-20b | USA West (Oregon) | us-west-2 | grundsteinmantel.us-west-2.api.aws |
| Königin | Qwen 3 32 B | qwen.qwen3-32b | USA West (Oregon) | us-west-2 | bedrock-mantle.us-west-2.api.aws |
# Zugang und Sicherheit für Modelle mit offenem Gewicht
Bevor Sie mit der Reinforcement Fine-Tuning (RFT) 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.
## Voraussetzungen
Bevor Sie die mit Amazon Bedrock OpenAI kompatible Feinabstimmung verwenden APIs, stellen Sie sicher, dass Sie über Folgendes verfügen:
1. Ein AWS Konto mit entsprechenden Berechtigungen für den Zugriff auf Amazon Bedrock
1. **Authentifizierung** — Sie können sich authentifizieren mit:
+ Amazon Bedrock API-Schlüssel (für OpenAI SDK erforderlich und für HTTP-Anfragen verfügbar)
+ AWS Anmeldeinformationen (unterstützt für HTTP-Anfragen)
**Anmerkung**
[Wenn Sie kurz- und langfristige API-Schlüssel von Amazon Bedrock verwenden, stellen Sie sicher, dass Ihre Rolle Zugriff auf die folgenden IAM-Richtlinienberechtigungen hat: und Rolle. `AmazonBedrockMantleFullAccess` AWSLambda](https://docs.aws.amazon.com/bedrock/latest/ug/rft-open-weight-access-security#openai-fine-tuning-lambda-permissions)
1. **OpenAISDK (optional)** — Installieren Sie das OpenAI Python-SDK, wenn Sie SDK-basierte Anfragen verwenden.
1. **Umgebungsvariablen** — Legen Sie die folgenden Umgebungsvariablen fest:
+ `OPENAI_API_KEY`— Stellen Sie Ihren Amazon Bedrock API-Schlüssel ein
+ `OPENAI_BASE_URL`— Stellen Sie den Amazon Bedrock-Endpunkt für Ihre Region ein (z. B.`https://bedrock-mantle.us-west-2.api.aws/v1`)
Weitere Informationen finden Sie unter [Antworten-API](bedrock-mantle.md#bedrock-mantle-responses).
1. **Trainingsdaten**, die zu diesem Zweck als JSONL-Dateien formatiert wurden. `fine-tune` Weitere Informationen finden Sie unter [Daten für Modelle mit offenem Gewicht vorbereiten](rft-prepare-data-open-weight.md).
## Lambda-Berechtigungen für Belohnungsfunktionen
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"
]
}
]
}
```
Sie können auch von Amazon Bedrock gehostete Modelle als Judges für die Einrichtung von Prämienfunktionen verwenden. Sie müssen der Lambda-Ausführungsrolle spezifische Berechtigungen hinzufügen, um Foundation-Modelle aufzurufen. In Ihrer Lambda-Rolle können Sie diese verwalteten Richtlinien für LLMs die Benotung konfigurieren. Siehe [AmazonBedrockLimitedAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockLimitedAccess.html).
Im Folgenden finden Sie ein Beispiel für den Aufruf von Amazon Bedrock Foundation-Modellen als Judge mithilfe der Invoke API:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:*:*:foundation-model/*"
]
}
]
}
```
# Daten für Modelle mit offenem Gewicht vorbereiten
Wenn Sie Open-Weight-Modelle mit Verstärkungsfeinabstimmung mithilfe von OpenAI-Compatible verfeinern APIs, stellen Sie Trainingsdaten bereit, indem Sie zu diesem Zweck Ihre eigenen Eingabeaufforderungen im JSONL-Format mitbringen. `fine-tune`
## Format und Anforderungen der Trainingsdaten
Die Trainingsdaten müssen dem OpenAI-Format für Chat-Vervollständigungen mit 100-20.000 Beispielen entsprechen. Jedes Trainingsbeispiel enthält:
+ `messages`: Geben Sie in dieses Feld die Benutzer-, System- oder Assistentenrolle ein, die die Eingabeaufforderung für das Modell 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)
+ Der Zweck muss auf eingestellt sein `fine-tune`
+ 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"]
}
}
```
------
## Datei-API
Sie können die OpenAI-kompatible Datei-API verwenden, um Ihre Trainingsdaten für die Feinabstimmung von Jobs hochzuladen. Dateien werden sicher in Amazon Bedrock gespeichert und bei der Erstellung von Feinabstimmungsaufträgen verwendet. Vollständige API-Details finden Sie in der Dokumentation zu [OpenAIDateien](https://platform.openai.com/docs/api-reference/files).
### Laden Sie die Trainingsdatei hoch
Um eine Trainingsdatei hochzuladen, wählen Sie die Registerkarte für Ihre bevorzugte Methode und gehen Sie dann wie folgt vor:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Upload training file
with open(TRAINING_FILE_PATH, 'rb') as f:
file_response = client.files.create(
file=f,
purpose='fine-tune'
)
# Store file ID for next steps
training_file_id = file_response.id
print(f"✅ Training file uploaded successfully: {training_file_id}")
```
------
#### [ HTTP request ]
Stellen Sie eine POST-Anfrage an`/v1/files`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-F purpose="fine-tune" \
-F file="@training_data.jsonl"
```
------
### Dateidetails abrufen
Um Details zu einer bestimmten Datei abzurufen, wählen Sie die Registerkarte für Ihre bevorzugte Methode und gehen Sie dann wie folgt vor:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Retrieve file details
file_details = client.files.retrieve(training_file_id)
# Print raw response
print(json.dumps(file_details.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Stellen Sie eine GET-Anfrage an`/v1/files/{file_id}`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Dateien auflisten
Um hochgeladene Dateien aufzulisten, wählen Sie die Registerkarte für Ihre bevorzugte Methode und folgen Sie dann den Schritten:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List files
files_response = client.files.list(purpose='fine-tune')
# Print raw response
print(json.dumps(files_response.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Stellen Sie eine GET-Anfrage an`/v1/files`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files?purpose=fine-tune \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Datei löschen
Um eine Datei zu löschen, wählen Sie die Registerkarte für Ihre bevorzugte Methode und folgen Sie dann den Schritten:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Delete file
delete_response = client.files.delete(training_file_id)
```
------
#### [ HTTP request ]
Stellen Sie eine DELETE-Anfrage an`/v1/files/{file_id}`:
```
curl -X DELETE https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Eigenschaften effektiver Trainingsdaten
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
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
}
```
------
# Einrichtung von Belohnungsfunktionen für Modelle mit offenem Gewicht
Belohnungsfunktionen bewerten die Antwortqualität und liefern Feedbacksignale für das Modelltraining. Sie können Belohnungsfunktionen mit benutzerdefinierten Lambda-Funktionen einrichten. Wählen Sie den Ansatz, der Ihren Aufgabenanforderungen entspricht.
## Benutzerdefinierte Lambda-Funktionen für die Bewertung von Belohnungen
Sie können Belohnungsfunktionen mit benutzerdefinierten Lambda-Funktionen einrichten. Innerhalb Ihrer Lambda-Funktion haben Sie Flexibilität bei der Implementierung der Bewertungslogik:
+ **Objektive Aufgaben** — Verwenden Sie für objektive Aufgaben wie Codegenerierung oder mathematisches Denken überprüfbare regelbasierte Korrektoren, die die Richtigkeit anhand bekannter Standards oder Testfälle überprüfen.
+ **Subjektive Aufgaben** — Rufen Sie bei subjektiven Aufgaben wie der Befolgung von Anweisungen oder Chatbot-Interaktionen Amazon Bedrock Foundation-Modelle als Richter innerhalb Ihrer Lambda-Funktion auf, um die Antwortqualität anhand Ihrer Kriterien zu bewerten.
Ihre Lambda-Funktion kann je nach Aufgabenanforderungen komplexe Logik implementieren APIs, externe integrieren, mehrstufige Berechnungen durchführen oder mehrere Bewertungskriterien kombinieren.
**Anmerkung**
Wenn Sie benutzerdefinierte Lambda-Funktionen verwenden:
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 der Lambda-Funktion, wie unter beschrieben. [Lambda-Berechtigungen für Belohnungsfunktionen](rft-open-weight-access-security.md#openai-fine-tuning-lambda-permissions)
## Einzelheiten zur Implementierung der Lambda-Funktion
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
# Erstellen und verwalten Sie Feinabstimmungsaufträge für Open-Weight-Modelle mit OpenAI APIs
Mit dem OpenAI-kompatiblen Feinabstimmungsjob APIs können Sie Feinabstimmungsjobs erstellen, überwachen und verwalten. Auf dieser Seite wird beschrieben, wie diese für die Feinabstimmung von Verstärkungen verwendet werden APIs . Vollständige API-Details finden Sie in der Dokumentation zur [OpenAIFeinabstimmung](https://platform.openai.com/docs/api-reference/fine-tuning).
## Erstellen Sie einen Feinabstimmungsauftrag
Erstellt einen Feinabstimmungsauftrag, der den Prozess der Erstellung eines neuen Modells aus einem bestimmten Datensatz einleitet. Vollständige API-Details finden Sie in der Dokumentation [Feinabstimmungsjobs OpenAI erstellen](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/create).
### Beispiele
Um einen Job zur Feinabstimmung mit der RFT-Methode zu erstellen, wählen Sie die Registerkarte für Ihre bevorzugte Methode und folgen Sie dann den Schritten:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Create fine-tuning job with RFT method
job_response = client.fine_tuning.jobs.create(
model=MODEL_ID,
training_file=training_file_id,
# Suffix field is not supported so commenting for now.
# suffix="rft-example", # Optional: suffix for fine-tuned model name
extra_body={
"method": {
"type": "reinforcement",
"reinforcement": {
"grader": {
"type": "lambda",
"lambda": {
"function": "arn:aws:lambda:us-west-2:123456789012:function:my-reward-function" # Replace with your Lambda ARN
}
},
"hyperparameters": {
"n_epochs": 1, # Number of training epochs
"batch_size": 4, # Batch size
"learning_rate_multiplier": 1.0 # Learning rate multiplier
}
}
}
}
)
# Store job ID for next steps
job_id = job_response.id
print({job_id})
```
------
#### [ HTTP request ]
Stellen Sie eine POST-Anfrage an: `/v1/fine_tuning/jobs`
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"training_file": "file-abc123",
"model": "gpt-4o-mini",
"method": {
"type": "reinforcement",
"reinforcement": {
"grader": {
"type": "lambda",
"lambda": {
"function": "arn:aws:lambda:us-west-2:123456789012:function:my-grader"
}
},
"hyperparameters": {
"n_epochs": 1,
"batch_size": 4,
"learning_rate_multiplier": 1.0
}
}
}
}'
```
------
## Führt Feinabstimmungsereignisse auf
Listet Ereignisse für eine Feinabstimmungsaufgabe auf. Feinabstimmungsereignisse bieten detaillierte Informationen über den Fortschritt Ihres Jobs, einschließlich Trainingsmetriken, Erstellung von Checkpoints und Fehlermeldungen. Vollständige API-Details finden Sie in der Dokumentation zur [Feinabstimmung von OpenAI Listen](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list_events).
### Beispiele
Um Feinabstimmungsereignisse aufzulisten, wählen Sie die Registerkarte für Ihre bevorzugte Methode und folgen Sie dann den Schritten:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List fine-tuning events
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id="ftjob-abc123",
limit=50
)
for event in events.data:
print(f"[{event.created_at}] {event.level}: {event.message}")
if event.data:
print(f" Metrics: {event.data}")
```
------
#### [ HTTP request ]
Stellen Sie eine GET-Anfrage an`/v1/fine_tuning/jobs/{fine_tuning_job_id}/events`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=50
```
------
Ereignisse beinhalten Informationen wie:
+ Meldungen über den Beginn und den Abschluss der Schulung
+ Benachrichtigungen zur Erstellung von Checkpoints
+ Trainingsmetriken (Verlust, Genauigkeit) bei jedem Schritt
+ Fehlermeldungen, wenn der Job fehlschlägt
Um alle Ereignisse nacheinander zu durchsuchen, wählen Sie die Registerkarte für Ihre bevorzugte Methode und gehen Sie dann wie folgt vor:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Paginate through all events
all_events = []
after = None
while True:
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id="ftjob-abc123",
limit=100,
after=after
)
all_events.extend(events.data)
if not events.has_more:
break
after = events.data[-1].id
```
------
#### [ HTTP request ]
Stellen Sie mehrere GET-Anfragen mit dem folgenden `after` Parameter:
```
# First request
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=100
# Subsequent requests with 'after' parameter
curl "https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/events?limit=100&after=ft-event-abc123"
```
------
## Finetuning-Job abrufen
Erhalten Sie detaillierte Informationen zu einem Feinsteuerungsjob. Vollständige API-Details finden Sie in der Dokumentation zum [OpenAIRetrieve-Feintuning-Job](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/retrieve).
### Beispiele
Um bestimmte Auftragsdetails abzurufen, wählen Sie die Registerkarte für Ihre bevorzugte Methode und folgen Sie dann den Schritten:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Retrieve specific job details
job_details = client.fine_tuning.jobs.retrieve(job_id)
# Print raw response
print(json.dumps(job_details.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Stellen Sie eine GET-Anfrage an`/v1/fine_tuning/jobs/{fine_tuning_job_id}`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Aufgaben zur Feinabstimmung auflisten
Führt die Feinabstimmungsaufgaben Ihrer Organisation mit Paginierungsunterstützung auf. Vollständige API-Details finden Sie in der Dokumentation zur [Feinabstimmung von OpenAI Listen](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list).
### Beispiele
Um Aufträge zur Feinabstimmung mit Limit und Seitennummerierung aufzulisten, wählen Sie die Registerkarte für Ihre bevorzugte Methode und gehen Sie dann wie folgt vor:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List fine-tuning jobs with limit and pagination
response = client.fine_tuning.jobs.list(
limit=20 # Maximum number of jobs to return
)
# Print raw response
print(json.dumps(response.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Stellen Sie eine GET-Anfrage an: `/v1/fine_tuning/jobs`
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs?limit=20 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Feinabstimmungsauftrag abbrechen
Bricht einen laufenden Feinabstimmungsauftrag ab. Nach dem Abbruch kann der Job nicht wieder aufgenommen werden. Vollständige API-Details finden Sie in der Dokumentation zum [Feintuning-Job OpenAI „Abbrechen“](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/cancel).
### Beispiele
Um einen Feinabstimmungsauftrag abzubrechen, wählen Sie die Registerkarte für Ihre bevorzugte Methode und folgen Sie dann den Schritten:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Cancel fine-tuning job
cancel_response = client.fine_tuning.jobs.cancel("ftjob-abc123")
print(f"Job ID: {cancel_response.id}")
print(f"Status: {cancel_response.status}") # Should be "cancelled"
```
------
#### [ HTTP request ]
Stellen Sie eine POST-Anfrage an`/v1/fine_tuning/jobs/{fine_tuning_job_id}/cancel`:
```
curl -X POST https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/cancel \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
## Listet Checkpoints für die Feinabstimmung auf
Listet Checkpoints für einen Feinabstimmungsjob auf. Bei Checkpoints handelt es sich um während der Feinabstimmung erstellte Schnappschüsse eines Modells, die als Rückschlüsse zur Bewertung der Leistung in verschiedenen Trainingsphasen verwendet werden können. Weitere Informationen finden Sie in der Dokumentation Checkpoints zur Feinabstimmung von [OpenAIListen](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/subresources/checkpoints/methods/list).
### Beispiele
Um Checkpoints für eine Feinabstimmungsaufgabe aufzulisten, wählen Sie die Registerkarte für Ihre bevorzugte Methode und gehen Sie dann wie folgt vor:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# List checkpoints for a fine-tuning job
checkpoints = client.fine_tuning.jobs.checkpoints.list(
fine_tuning_job_id="ftjob-abc123",
limit=10
)
for checkpoint in checkpoints.data:
print(f"Checkpoint ID: {checkpoint.id}")
print(f"Step: {checkpoint.step_number}")
print(f"Model: {checkpoint.fine_tuned_model_checkpoint}")
print(f"Metrics: {checkpoint.metrics}")
print("---")
```
------
#### [ HTTP request ]
Stellen Sie eine GET-Anfrage an: `/v1/fine_tuning/jobs/{fine_tuning_job_id}/checkpoints`
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/fine_tuning/jobs/ftjob-abc123/checkpoints?limit=10
```
------
Jeder Checkpoint beinhaltet:
+ **Checkpoint-ID** — Eindeutige Kennung für den Checkpoint
+ **Schrittnummer** — Trainingsschritt, bei dem der Checkpoint erstellt wurde
+ **Modell-Checkpoint** — Modell-ID, die für Rückschlüsse verwendet werden kann
+ **Metriken** — Validierungsverlust und Genauigkeit an diesem Checkpoint
Um ein Checkpoint-Modell für Inferenzen zu verwenden, wählen Sie die Registerkarte für Ihre bevorzugte Methode und gehen Sie dann wie folgt vor:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Test inference with a checkpoint
response = client.chat.completions.create(
model=checkpoint.fine_tuned_model_checkpoint,
messages=[{"role": "user", "content": "What is AI?"}],
max_tokens=100
)
print(response.choices[0].message.content)
```
------
#### [ HTTP request ]
Stellen Sie eine POST-Anfrage an: `/v1/chat/completions`
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "ft:gpt-4o-mini:openai:custom:7p4lURel:ckpt-step-1000",
"messages": [{"role": "user", "content": "What is AI?"}],
"max_tokens": 100
}'
```
------
## Führen Sie die Inferenz mit einem fein abgestimmten Modell aus
Sobald Ihre Feinabstimmung abgeschlossen ist, können Sie das fein abgestimmte Modell für Inferenzen über die Responses API oder Chat Completions API verwenden. Vollständige API-Einzelheiten finden Sie unter. [Generieren Sie Antworten mit OpenAI APIs](bedrock-mantle.md)
### API für Antworten
Verwenden Sie die Responses API für die Generierung von Single-Turn-Text mit Ihrem fein abgestimmten Modell:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Get the fine-tuned model ID
job_details = client.fine_tuning.jobs.retrieve("ftjob-abc123")
if job_details.status == 'succeeded' and job_details.fine_tuned_model:
fine_tuned_model = job_details.fine_tuned_model
print(f"Using fine-tuned model: {fine_tuned_model}")
# Run inference with Responses API
response = client.completions.create(
model=fine_tuned_model,
prompt="What is the capital of France?",
max_tokens=100,
temperature=0.7
)
print(f"Response: {response.choices[0].text}")
else:
print(f"Job status: {job_details.status}")
print("Job must be in 'succeeded' status to run inference")
```
------
#### [ HTTP request ]
Stellen Sie eine POST-Anfrage an: `/v1/completions`
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "ft:gpt-4o-mini:openai:custom-model:7p4lURel",
"prompt": "What is the capital of France?",
"max_tokens": 100,
"temperature": 0.7
}'
```
------
### API für Chat-Abschlüsse
Verwenden Sie die Chat-Completions-API für Konversationsinteraktionen mit Ihrem fein abgestimmten Modell:
------
#### [ OpenAI SDK (Python) ]
```
# Requires OPENAI_API_KEY and OPENAI_BASE_URL environment variables
from openai import OpenAI
client = OpenAI()
# Get the fine-tuned model ID
job_details = client.fine_tuning.jobs.retrieve("ftjob-abc123")
if job_details.status == 'succeeded' and job_details.fine_tuned_model:
fine_tuned_model = job_details.fine_tuned_model
print(f"Using fine-tuned model: {fine_tuned_model}")
# Run inference
inference_response = client.chat.completions.create(
model=fine_tuned_model,
messages=[
{"role": "user", "content": "What is the capital of France?"}
],
max_tokens=100
)
print(f"Response: {inference_response.choices[0].message.content}")
else:
print(f"Job status: {job_details.status}")
print("Job must be in 'succeeded' status to run inference")
```
------
#### [ HTTP request ]
Stellen Sie eine POST-Anfrage an: `/v1/chat/completions`
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-d '{
"model": "ft:gpt-4o-mini:openai:custom-model:7p4lURel",
"messages": [
{"role": "user", "content": "What is the capital of France?"}
],
"max_tokens": 100
}'
```
------