Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Ajustez les modèles à poids ouvert à l'aide de -compatible OpenAI APIs
Amazon Bedrock fournit des points de terminaison d'API OpenAI compatibles pour affiner les modèles de base. Ces points de terminaison vous permettent d'utiliser des outils familiers OpenAI SDKs pour créer, surveiller et gérer des tâches de réglage précis avec les modèles Amazon Bedrock. Cette page décrit leur utilisation APIs pour affiner le renforcement.
## Capacités clés
+ **Télécharger des fichiers de formation** : utilisez l'API Files pour télécharger et gérer les données de formation afin de peaufiner les tâches
+ **Créez des tâches de réglage précis** — Commencez à peaufiner les tâches grâce à des données d'entraînement personnalisées et à des fonctions de récompense
+ **Répertorier et récupérer les tâches** : consultez toutes les tâches de réglage précis et obtenez des informations détaillées sur des tâches spécifiques
+ **Surveillez les événements liés aux tâches** : suivez la progression des ajustements grâce à des journaux d'événements détaillés
+ **Points de contrôle d'accès** — Récupérez les points de contrôle du modèle intermédiaire créés pendant la formation
+ **Inférence immédiate** — Une fois le réglage terminé, utilisez le modèle affiné qui en résulte pour une inférence à la demande via la APIs compatibilité OpenAI d'Amazon Bedrock (API de réponses et de complétions de chat) sans étapes de déploiement supplémentaires
+ **Migration facile** — Compatible avec les bases de OpenAI code SDK existantes
## Renfort : optimisation du flux de travail pour les modèles à poids ouvert
Avant de peaufiner le réglage, assurez-vous de remplir les conditions préalables, car Amazon Bedrock a besoin d'autorisations spécifiques pour créer et gérer le processus de mise au point. Pour obtenir des informations complètes sur la sécurité et les autorisations, consultez[Accès et sécurité pour les modèles à poids ouvert](rft-open-weight-access-security.md).
Effectuez le réglage précis du renforcement pour les modèles à poids ouvert en 5 étapes :
1. **Télécharger le jeu de données d'entraînement** — Utilisez l'API Files pour télécharger les instructions dans le format requis (par exemple, JSONL) dans le but de les « peaufiner » en tant que jeu de données d'entraînement peaufinant le renforcement. Pour de plus amples informations, veuillez consulter [Préparer les données pour les modèles à pondération ouverte](rft-prepare-data-open-weight.md).
1. **Configurer la fonction de récompense** : définissez un évaluateur pour évaluer les réponses du modèle en fonction de l'exactitude, de la structure, du ton ou d'autres objectifs à l'aide des fonctions Lambda. Pour de plus amples informations, veuillez consulter [Configuration des fonctions de récompense pour les modèles à poids ouvert](reward-functions-open-weight.md).
1. **Créer un travail de réglage précis** : lancez le travail de réglage fin du renforcement à l'aide de l'API OpenAI compatible en spécifiant le modèle de base, l'ensemble de données, la fonction de récompense et d'autres paramètres facultatifs tels que les hyperparamètres. Pour de plus amples informations, veuillez consulter [Créez un travail de réglage précis](fine-tuning-openai-job-create.md#fine-tuning-openai-create-job).
1. **Surveillez les progrès de la formation** : suivez l'état des tâches, les événements et les indicateurs de formation à l'aide des tâches APIs de réglage précis. Pour de plus amples informations, veuillez consulter [Répertorier les événements de réglage](fine-tuning-openai-job-create.md#fine-tuning-openai-list-events). Accédez aux points de contrôle du modèle intermédiaire pour évaluer les performances à différentes étapes de l'entraînement, voir[Répertorier les points de contrôle pour affiner](fine-tuning-openai-job-create.md#fine-tuning-openai-list-checkpoints).
1. **Exécutez l'inférence** : utilisez directement l'identifiant du modèle affiné pour effectuer des inférences via les réponses ou les terminaisons de chat OpenAI compatibles avec Amazon Bedrock. APIs Pour de plus amples informations, veuillez consulter [Exécutez l'inférence avec un modèle affiné](fine-tuning-openai-job-create.md#fine-tuning-openai-inference).
## Régions et terminaux pris en charge
Le tableau suivant présente les modèles de base et les régions qui prennent en charge le réglage fin OpenAI APIs compatible :
**Modèles et régions pris en charge pour un réglage précis de la OpenAI compatibilité APIs**
| Fournisseur | Modèle | ID du modèle | Nom de la région | Région | Endpoint |
| --- | --- | --- | --- | --- | --- |
| OpenAI | GPT-OSS-20b | openai.gpt-oss-20b | USA Ouest (Oregon) | us-west-2 | bedrock-mantle.us-west-2.api.aws |
| Qwen | Qwen3 32B | qwen.qwen3-32b | USA Ouest (Oregon) | us-west-2 | bedrock-mantle.us-west-2.api.aws |
# Accès et sécurité pour les modèles à poids ouvert
Avant de commencer le réglage fin du renforcement (RFT), assurez-vous de comprendre le type d'accès dont Amazon Bedrock a besoin pour les opérations spécifiques au RFT. RFT nécessite des autorisations supplémentaires au-delà du réglage précis standard en raison de ses capacités d'exécution de la fonction de récompense.
## Conditions préalables
Avant d'utiliser le réglage fin OpenAI compatible avec Amazon Bedrock APIs, assurez-vous de disposer des éléments suivants :
1. Un AWS compte avec les autorisations appropriées pour accéder à Amazon Bedrock
1. **Authentification** — Vous pouvez vous authentifier en utilisant :
+ Clé d'API Amazon Bedrock (requise pour le OpenAI SDK et disponible pour les requêtes HTTP)
+ AWS informations d'identification (prises en charge pour les requêtes HTTP)
**Note**
[Si vous utilisez des clés d'API à court et à long terme d'Amazon Bedrock, assurez-vous que votre rôle a accès aux autorisations de politique IAM suivantes : et Rôle. `AmazonBedrockMantleFullAccess` AWSLambda](https://docs.aws.amazon.com/bedrock/latest/ug/rft-open-weight-access-security#openai-fine-tuning-lambda-permissions)
1. **OpenAISDK (facultatif)** — Installez le SDK OpenAI Python si vous utilisez des requêtes basées sur le SDK.
1. **Variables d'environnement** : définissez les variables d'environnement suivantes :
+ `OPENAI_API_KEY`— Réglé sur votre clé d'API Amazon Bedrock
+ `OPENAI_BASE_URL`— Définissez le point de terminaison Amazon Bedrock de votre région (par exemple,`https://bedrock-mantle.us-west-2.api.aws/v1`)
Pour de plus amples informations, veuillez consulter [API de réponses](bedrock-mantle.md#bedrock-mantle-responses).
1. **Les données d'entraînement sont** formatées sous forme de fichiers JSONL dans ce but. `fine-tune` Pour de plus amples informations, veuillez consulter [Préparer les données pour les modèles à pondération ouverte](rft-prepare-data-open-weight.md).
## Autorisations Lambda pour les fonctions de récompense
Vous devez ajouter des autorisations d'appel Lambda. Voici un exemple de politique que vous pouvez utiliser :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:reward-function-name"
]
}
]
}
```
Vous pouvez également utiliser les modèles hébergés par Amazon Bedrock en tant que juges pour configurer les fonctions de récompense. Vous devrez ajouter des autorisations spécifiques pour invoquer des modèles de base dans le rôle d'exécution Lambda. Dans votre rôle Lambda, vous pouvez configurer ces politiques gérées à des LLMs fins de notation. Consultez [AmazonBedrockLimitedAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockLimitedAccess.html).
Voici un exemple d'appel des modèles de fondation Amazon Bedrock en tant que juge à l'aide de l'API Invoke :
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:*:*:foundation-model/*"
]
}
]
}
```
# Préparer les données pour les modèles à pondération ouverte
Lorsque vous peaufinez des modèles à poids ouvert avec un ajustement précis du renforcement à l'aide de la compatibilité OpenAI APIs, fournissez des données d'entraînement en apportant vos propres instructions au format JSONL dans ce but. `fine-tune`
## Format et exigences des données de formation
Les données de formation doivent suivre le format de complétion des discussions OpenAI avec 100 à 20 000 exemples. Chaque exemple de formation contient :
+ `messages`: Dans ce champ, incluez le rôle d'utilisateur, de système ou d'assistant contenant l'invite de saisie fournie au modèle.
+ `reference_answer`: Dans ce champ, il doit contenir le résultat attendu ou les critères d'évaluation que votre fonction de récompense utilise pour évaluer la réponse du modèle. Il ne se limite pas aux sorties structurées : il peut contenir n'importe quel format permettant à votre fonction de récompense d'évaluer la qualité.
+ [Facultatif] Vous pouvez ajouter des champs utilisés par l'évaluateur Lambda pour la notation.
**Prérequis:**
+ Format JSONL avec instructions au format d'achèvement du chat OpenAI (une invite par ligne)
+ L'objectif doit être défini sur `fine-tune`
+ Un minimum de 100 enregistrements dans l'ensemble de données de formation
+ Amazon Bedrock valide automatiquement le format du jeu de données d'entraînement
------
#### [ 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"]
}
}
```
------
## API de fichiers
Vous pouvez utiliser l'API de fichiers compatible avec OpenAI pour télécharger vos données d'entraînement afin de peaufiner les tâches. Les fichiers sont stockés en toute sécurité dans Amazon Bedrock et sont utilisés lors de la création de tâches de peaufinage. Pour obtenir des informations complètes sur l'API, consultez la [documentation relative aux OpenAI fichiers](https://platform.openai.com/docs/api-reference/files).
### Téléchargez le fichier de formation
Pour télécharger un fichier de formation, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Faites une demande POST pour `/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"
```
------
### Récupérer les détails du fichier
Pour récupérer les informations relatives à un fichier spécifique, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Envoyez une requête GET à `/v1/files/{file_id}` :
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Lister les fichiers
Pour répertorier les fichiers téléchargés, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Envoyez une requête GET à `/v1/files` :
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files?purpose=fine-tune \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Supprimer le fichier
Pour supprimer un fichier, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Envoyez une demande DELETE à `/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"
```
------
## Caractéristiques des données d'entraînement efficaces
Des données d'entraînement RFT efficaces nécessitent trois caractéristiques clés :
+ **Clarté et cohérence** : utilisez des instructions claires et sans ambiguïté avec un formatage uniforme. Évitez les étiquettes contradictoires, les instructions ambiguës ou les réponses de référence contradictoires qui induisent en erreur la formation.
+ **Diversité** — Incluez différents formats de saisie, scénarios extrêmes et niveaux de difficulté qui reflètent les modèles d'utilisation de la production selon les différents types d'utilisateurs et scénarios.
+ **Fonctions de récompense efficaces** — Concevez des fonctions qui s'exécutent rapidement (en quelques secondes, et non en minutes), sont parallélisées et AWS Lambda fournissent des scores cohérents pour un entraînement rentable.
## Propriétés supplémentaires
Le format de données RFT prend en charge les champs personnalisés au-delà des exigences de base du schéma (`messages`et`reference_answer`). Cette flexibilité vous permet d'ajouter toutes les données supplémentaires dont votre fonction de récompense a besoin pour une évaluation correcte.
**Note**
Vous n'avez pas besoin de le configurer dans votre recette. Le format de données prend en charge de manière inhérente des champs supplémentaires. Il suffit de les inclure dans le JSON de vos données d'entraînement, et elles seront transmises à votre fonction de récompense `metadata` sur le terrain.
**Propriétés supplémentaires communes**
+ `task_id`— Identifiant unique pour le suivi
+ `difficulty_level`— Indicateur de complexité du problème
+ `domain`— Domaine ou catégorie
+ `expected_reasoning_steps`— Nombre d'étapes de la solution
Ces champs supplémentaires sont transmis à votre fonction de récompense lors de l'évaluation, ce qui permet une logique de notation sophistiquée adaptée à votre cas d'utilisation spécifique.
**Exemples avec propriétés supplémentaires**
------
#### [ 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
}
}
```
Le `reference_answer` champ contient le résultat attendu ou les critères d'évaluation que votre fonction de récompense utilise pour évaluer la réponse du modèle. Il ne se limite pas aux sorties structurées : il peut contenir n'importe quel format permettant à votre fonction de récompense d'évaluer la qualité.
------
#### [ 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
}
```
------
# Configuration des fonctions de récompense pour les modèles à poids ouvert
Les fonctions de récompense évaluent la qualité des réponses et fournissent des signaux de rétroaction pour l'entraînement des modèles. Vous pouvez configurer des fonctions de récompense à l'aide de fonctions Lambda personnalisées. Choisissez l'approche qui correspond aux exigences de votre tâche.
## Fonctions Lambda personnalisées pour l'évaluation des récompenses
Vous pouvez configurer des fonctions de récompense à l'aide de fonctions Lambda personnalisées. Au sein de votre fonction Lambda, vous disposez d'une certaine flexibilité dans la manière dont vous implémentez la logique d'évaluation :
+ **Tâches objectives** : pour les tâches objectives telles que la génération de code ou le raisonnement mathématique, utilisez des évaluateurs vérifiables basés sur des règles qui vérifient l'exactitude par rapport à des normes ou à des scénarios de test connus.
+ **Tâches subjectives** : pour les tâches subjectives telles que le suivi des instructions ou les interactions avec un chatbot, faites appel aux modèles Amazon Bedrock Foundation en tant que juges au sein de votre fonction Lambda afin d'évaluer la qualité des réponses en fonction de vos critères.
Votre fonction Lambda peut implémenter une logique complexe, intégrer des éléments externes APIs, effectuer des calculs en plusieurs étapes ou combiner plusieurs critères d'évaluation en fonction des exigences de votre tâche.
**Note**
Lorsque vous utilisez des fonctions Lambda personnalisées :
Augmentez le délai Lambda de 3 secondes par défaut à 15 minutes maximum pour les évaluations complexes.
Le rôle d'exécution Lambda a besoin d'autorisations pour appeler la fonction Lambda, comme décrit dans. [Autorisations Lambda pour les fonctions de récompense](rft-open-weight-access-security.md#openai-fine-tuning-lambda-permissions)
## Détails de mise en œuvre de la fonction Lambda
Lorsque vous implémentez des fonctions de récompense Lambda personnalisées, votre fonction doit accepter et renvoyer des données au format suivant.
------
#### [ 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"
}
]
}]
```
------
**Directives de conception**
+ **Classez les réponses** — Donnez à la meilleure réponse un score nettement supérieur
+ **Utilisez des contrôles cohérents** : évaluez l'achèvement des tâches, le respect du format, la sécurité et une durée raisonnable
+ **Maintenez une mise à l'échelle stable** : maintenez les scores normalisés et non exploitables
# Créez et gérez des tâches de réglage précis pour les modèles à poids ouvert à l'aide d'OpenAI APIs
Les tâches de réglage fin compatibles avec OpenAI vous APIs permettent de créer, de surveiller et de gérer des tâches de réglage précis. Cette page décrit leur utilisation APIs pour affiner le renforcement. Pour obtenir des informations complètes sur l'API, consultez la [documentation relative OpenAI au réglage précis](https://platform.openai.com/docs/api-reference/fine-tuning).
## Créez un travail de réglage précis
Crée une tâche de réglage fin qui lance le processus de création d'un nouveau modèle à partir d'un jeu de données donné. Pour obtenir des informations complètes sur l'API, consultez la [documentation relative à la OpenAI création de tâches de réglage précis](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/create).
### Exemples
Pour créer une tâche de réglage précis avec la méthode RFT, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Faites une demande POST pour `/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
}
}
}
}'
```
------
## Répertorier les événements de réglage
Répertorie les événements nécessaires à une tâche de mise au point. Les événements de réglage précis fournissent des informations détaillées sur l'avancement de votre travail, notamment les indicateurs de formation, la création de points de contrôle et les messages d'erreur. Pour obtenir des informations complètes sur l'API, consultez la [documentation relative à la OpenAI liste des événements de réglage précis](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list_events).
### Exemples
Pour répertorier les événements de réglage précis, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Envoyez une requête GET à l'adresse suivante `/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
```
------
Les événements incluent des informations telles que :
+ Messages de début et de fin de la formation
+ Notifications de création de points de contrôle
+ Indicateurs d'entraînement (perte, précision) à chaque étape
+ Messages d'erreur en cas d'échec de la tâche
Pour paginer tous les événements, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Effectuez plusieurs requêtes GET avec le `after` paramètre :
```
# 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"
```
------
## Récupérez une tâche de réglage précis
Obtenez des informations détaillées sur une tâche de réglage précis. Pour obtenir des informations complètes sur l'API, consultez la [documentation relative aux tâches de réglage précis de OpenAI Retrieve](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/retrieve).
### Exemples
Pour récupérer les détails d'une tâche spécifique, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Envoyez une requête GET à l'adresse suivante `/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"
```
------
## Répertorier les tâches de réglage
Répertorie les tâches de peaufinage de votre organisation grâce à la prise en charge de la pagination. Pour obtenir des informations complètes sur l'API, consultez la [documentation relative à la OpenAI liste des tâches de réglage précis](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list).
### Exemples
Pour répertorier les tâches de réglage précis avec limite et pagination, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Envoyez une requête GET à l'adresse suivante `/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"
```
------
## Annuler le travail de réglage
Annule une tâche de réglage en cours. Une fois annulée, la tâche ne peut pas être reprise. Pour obtenir des informations complètes sur l'API, consultez la [documentation relative à l'OpenAIannulation de la tâche de réglage précis](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/cancel).
### Exemples
Pour annuler une tâche de réglage, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Faites une demande POST pour `/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"
```
------
## Répertorier les points de contrôle pour affiner
Répertorie les points de contrôle nécessaires à un travail de réglage précis. Les points de contrôle sont des instantanés de modèles intermédiaires créés lors du réglage précis qui peuvent être utilisés à des fins d'inférence pour évaluer les performances à différentes étapes de l'entraînement. Pour plus d'informations, consultez la documentation relative au [réglage précis OpenAI des points de contrôle de la liste](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/subresources/checkpoints/methods/list).
### Exemples
Pour répertorier les points de contrôle pour une tâche de réglage précis, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Envoyez une requête GET à l'adresse suivante `/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
```
------
Chaque point de contrôle inclut :
+ Identifiant du **point de contrôle — Identifiant** unique du point de contrôle
+ **Numéro d'étape** — Étape de formation au cours de laquelle le point de contrôle a été créé
+ **Point de contrôle du modèle** — Identifiant du modèle pouvant être utilisé pour l'inférence
+ **Métriques** — Perte de validation et précision à ce point de contrôle
Pour utiliser un modèle de point de contrôle à des fins d'inférence, choisissez l'onglet correspondant à votre méthode préférée, puis suivez les étapes suivantes :
------
#### [ 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 ]
Faites une demande POST pour `/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
}'
```
------
## Exécutez l'inférence avec un modèle affiné
Une fois votre travail de réglage terminé, vous pouvez utiliser le modèle affiné à des fins d'inférence via l'API Responses ou l'API Chat Completions. Pour obtenir des informations complètes sur l'API, consultez[Générez des réponses en utilisant OpenAI APIs](bedrock-mantle.md).
### API de réponses
Utilisez l'API Responses pour générer du texte en un tour avec votre modèle affiné :
------
#### [ 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 ]
Faites une demande POST pour `/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 de complétion des discussions
Utilisez l'API Chat Completions pour les interactions conversationnelles avec votre modèle affiné :
------
#### [ 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 ]
Faites une demande POST pour `/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
}'
```
------