Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Ajuste con precisión los modelos de peso abierto con -compatible OpenAI APIs
Amazon Bedrock proporciona puntos de enlace de API OpenAI compatibles para ajustar los modelos básicos. Estos puntos de conexión le permiten utilizar herramientas OpenAI SDKs y conocimientos para crear, supervisar y gestionar tareas de ajuste con los modelos de Amazon Bedrock. En esta página, se destaca su uso para reforzar los ajustes APIs .
## Capacidades clave
+ **Cargue archivos de formación**: utilice la API de archivos para cargar y gestionar los datos de formación para realizar tareas de ajuste
+ **Cree trabajos de ajuste preciso: comience a afinar los trabajos** con datos de entrenamiento personalizados y funciones de recompensa
+ **Enumere y recupere trabajos**: vea todos los trabajos de ajuste y obtenga información detallada sobre trabajos específicos
+ **Supervise los eventos de los trabajos**: realice un seguimiento del progreso del ajuste mediante registros de eventos detallados
+ **Puntos de control de acceso: recupere los puntos** de control del modelo intermedio creados durante el entrenamiento
+ **Inferencia inmediata**: una vez finalizado el ajuste, utilice el modelo ajustado resultante para realizar inferencias bajo demanda a través de OpenAI (API de respuestas y finalización de chat) de Amazon Bedrock sin pasos de implementación adicionales APIs
+ **Migración** sencillaOpenAI: compatible con las bases de código del SDK existentes
## Refuerce el flujo de trabajo de ajuste preciso para modelos de peso abierto
Antes de realizar los ajustes, asegúrese de cumplir con los requisitos previos, ya que Amazon Bedrock necesita permisos específicos para crear y gestionar el proceso de ajuste. Para obtener información completa sobre seguridad y permisos, consulte. [Acceso y seguridad para modelos de peso abierto](rft-open-weight-access-security.md)
Realice el ajuste preciso del refuerzo para modelos de peso abierto en 5 pasos:
1. **Cargue el conjunto de datos de entrenamiento**: utilice la API de archivos para cargar las instrucciones en el formato requerido (por ejemplo, JSONL) con el propósito de «ajustarlas» como refuerzo del conjunto de datos de entrenamiento. Para obtener más información, consulte [Prepare los datos para los modelos de peso abierto](rft-prepare-data-open-weight.md).
1. **Configurar la función de recompensa**: defina un calificador para puntuar las respuestas del modelo en función de la corrección, la estructura, el tono u otros objetivos mediante las funciones Lambda. Para obtener más información, consulte [Configuración de funciones de recompensa para modelos de peso abierto](reward-functions-open-weight.md).
1. **Crear trabajo de ajuste de precisión: inicie el trabajo** de ajuste de refuerzo mediante la API OpenAI compatible especificando el modelo base, el conjunto de datos, la función de recompensa y otros ajustes opcionales, como los hiperparámetros. Para obtener más información, consulte [Cree un trabajo de ajuste](fine-tuning-openai-job-create.md#fine-tuning-openai-create-job).
1. **Supervise el progreso de la capacitación**: realice un seguimiento del estado del trabajo, los eventos y las métricas de capacitación mediante los trabajos de ajuste detallado. APIs Para obtener más información, consulte [Enumere los eventos de ajuste](fine-tuning-openai-job-create.md#fine-tuning-openai-list-events). Acceda a los puntos de control de los modelos intermedios para evaluar el rendimiento en las diferentes etapas de la formación; consulte. [Enumere los puntos de control de ajuste](fine-tuning-openai-job-create.md#fine-tuning-openai-list-checkpoints)
1. **Ejecute una inferencia**: utilice el ID de modelo ajustado directamente para realizar inferencias a través de las respuestas o las terminaciones de chat compatibles con Amazon BedrockOpenAI. APIs Para obtener más información, consulte [Ejecute la inferencia con un modelo ajustado](fine-tuning-openai-job-create.md#fine-tuning-openai-inference).
## Regiones y puntos de enlace compatibles
En la siguiente tabla se muestran los modelos básicos y las regiones que admiten ajustes OpenAI precisos APIs compatibles:
**Modelos y regiones compatibles para OpenAI un ajuste fino compatible APIs**
| Proveedor | Modelo | ID del modelo | Nombre de la región | Región | Punto de conexión |
| --- | --- | --- | --- | --- | --- |
| OpenAI | GPT-OSS-20b | openai.gpt-oss-20b | Oeste de EE. UU. (Oregón) | us-west-2 | bedrock-mantle.us-west-2.api.aws |
| Qwen | Qwen3 32 B | qwen.qwen3-32b | Oeste de EE. UU. (Oregón) | us-west-2 | bedrock-mantle.us-west-2.api.aws |
# Acceso y seguridad para modelos de peso abierto
Antes de empezar con el ajuste preciso de refuerzos (RFT), asegúrese de entender qué tipo de acceso necesita Amazon Bedrock para las operaciones específicas de la RFT. RFT requiere permisos adicionales además de los ajustes estándar debido a sus capacidades de ejecución de funciones de recompensa.
## Requisitos previos
Antes de utilizar los ajustes precisos OpenAI compatibles con Amazon Bedrock APIs, asegúrese de disponer de lo siguiente:
1. Una AWS cuenta con los permisos adecuados para acceder a Amazon Bedrock
1. **Autenticación**: puede autenticarse mediante:
+ Clave de API de Amazon Bedrock (necesaria para el OpenAI SDK y disponible para las solicitudes HTTP)
+ AWS credenciales (compatibles con las solicitudes HTTP)
**nota**
[Si utiliza claves de API a corto o largo plazo de Amazon Bedrock, asegúrese de que su función tenga acceso a los siguientes permisos de política de IAM: y Rol. `AmazonBedrockMantleFullAccess` AWSLambda](https://docs.aws.amazon.com/bedrock/latest/ug/rft-open-weight-access-security#openai-fine-tuning-lambda-permissions)
1. **OpenAISDK (opcional)**: instala el SDK de OpenAI Python si utilizas solicitudes basadas en el SDK.
1. **Variables de entorno**: defina las siguientes variables de entorno:
+ `OPENAI_API_KEY`— Configúrelo en su clave de API de Amazon Bedrock
+ `OPENAI_BASE_URL`— Configúrelo en el punto final de Amazon Bedrock de su región (por ejemplo,`https://bedrock-mantle.us-west-2.api.aws/v1`)
Para obtener más información, consulte [API de respuestas](bedrock-mantle.md#bedrock-mantle-responses).
1. **Los datos de entrenamiento** se formatearon como archivos JSONL con este propósito. `fine-tune` Para obtener más información, consulte [Prepare los datos para los modelos de peso abierto](rft-prepare-data-open-weight.md).
## Permisos Lambda para funciones de recompensa
Debe añadir permisos de invocación a Lambda. A continuación, se muestra un ejemplo de política que puede utilizar:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:reward-function-name"
]
}
]
}
```
También puede utilizar modelos alojados en Amazon Bedrock como jueces para configurar las funciones de recompensa. Deberá añadir permisos específicos para invocar modelos básicos a la función de ejecución de Lambda. En su rol de lambda, puede configurar estas políticas administradas para LLMs la calificación. Consulte [AmazonBedrockLimitedAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockLimitedAccess.html).
El siguiente es un ejemplo de cómo invocar los modelos básicos de Amazon Bedrock como juez mediante la API Invoke:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:*:*:foundation-model/*"
]
}
]
}
```
# Prepare los datos para los modelos de peso abierto
Cuando ajustes modelos de peso abierto con ajustes de refuerzo compatibles con OpenAI APIs, proporciona datos de entrenamiento con tus propias indicaciones en formato JSONL con ese propósito. `fine-tune`
## Formato y requisitos de los datos de entrenamiento
Los datos de entrenamiento deben seguir el formato de finalización del chat de OpenAI con entre 100 y 20 000 ejemplos. Cada ejemplo de formación contiene:
+ `messages`: En este campo, incluya el rol de usuario, sistema o asistente que contiene la solicitud de entrada proporcionada al modelo.
+ `reference_answer`: En este campo, debe contener el resultado esperado o los criterios de evaluación que su función de recompensa utiliza para puntuar la respuesta del modelo. No se limita a los resultados estructurados, sino que puede contener cualquier formato que ayude a la función de recompensa a evaluar la calidad.
+ [Opcional] Puede agregar los campos utilizados por la calificadora Lambda para la calificación.
**Requisitos:**
+ Formato JSONL con mensajes en formato de finalización de chat de OpenAI (un mensaje por línea)
+ El propósito debe estar establecido en `fine-tune`
+ Un mínimo de 100 registros en el conjunto de datos de entrenamiento
+ Amazon Bedrock valida automáticamente el formato del conjunto de datos de entrenamiento
------
#### [ 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 archivos
Puedes usar la API de archivos compatibles con OpenAI para cargar tus datos de entrenamiento para trabajos de ajuste fino. Los archivos se almacenan de forma segura en Amazon Bedrock y se utilizan para crear trabajos de ajuste preciso. [Para obtener información completa sobre la API, consulte la OpenAI documentación de Files.](https://platform.openai.com/docs/api-reference/files)
### Cargue el archivo de formación
Para cargar un archivo de formación, elija la pestaña correspondiente al método que prefiera y, a continuación, siga los pasos:
------
#### [ 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 ]
Haga una solicitud POST a`/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"
```
------
### Recuperar los detalles del archivo
Para recuperar los detalles de un archivo específico, selecciona la pestaña del método que prefieras y, a continuación, sigue estos pasos:
------
#### [ 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 ]
Realiza una solicitud GET a`/v1/files/{file_id}`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files/file-abc123 \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Listar archivos
Para ver una lista de los archivos cargados, selecciona la pestaña del método que prefieras y, a continuación, sigue estos pasos:
------
#### [ 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 ]
Realiza una solicitud GET a`/v1/files`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files?purpose=fine-tune \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Eliminar archivo
Para eliminar un archivo, selecciona la pestaña del método que prefieras y, a continuación, sigue los pasos:
------
#### [ 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 ]
Realiza una solicitud de ELIMINACIÓN a`/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"
```
------
## Características de los datos de entrenamiento efectivos
Los datos de entrenamiento de RFT efectivos requieren tres características clave:
+ **Claridad y coherencia**: utilice indicaciones claras e inequívocas con un formato coherente. Evite las etiquetas contradictorias, las instrucciones ambiguas o las respuestas de referencia contradictorias que puedan inducir a error a la formación.
+ **Diversidad**: incluya formatos de entrada variados, casos extremos y niveles de dificultad que reflejen los patrones de uso de la producción en diferentes tipos de usuarios y escenarios.
+ **Funciones de recompensa eficientes**: diseñe funciones que se ejecuten rápidamente (en segundos, no en minutos), paralelicen y AWS Lambda arrojen puntuaciones uniformes para una formación rentable.
## Propiedades adicionales
El formato de datos RFT admite campos personalizados que van más allá de los requisitos básicos del esquema (y). `messages` `reference_answer` Esta flexibilidad le permite añadir cualquier dato adicional que su función de recompensas necesite para una evaluación adecuada.
**nota**
No necesitas configurar esto en tu receta. El formato de datos admite campos adicionales de forma inherente. Simplemente inclúyelos en el JSON de tus datos de entrenamiento y se transferirán a tu función de recompensas en el `metadata` campo.
**Propiedades adicionales comunes**
+ `task_id`— Identificador único para el seguimiento
+ `difficulty_level`— Indicador de complejidad del problema
+ `domain`— Área temática o categoría
+ `expected_reasoning_steps`— Número de pasos de la solución
Estos campos adicionales se transfieren a la función de recompensas durante la evaluación, lo que permite aplicar una lógica de puntuación sofisticada adaptada a su caso de uso específico.
**Ejemplos con propiedades adicionales**
------
#### [ 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
}
}
```
El `reference_answer` campo contiene el resultado esperado o los criterios de evaluación que la función de recompensa utiliza para puntuar la respuesta del modelo. No se limita a resultados estructurados, sino que puede contener cualquier formato que ayude a la función de recompensa a evaluar la calidad.
------
#### [ 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
}
```
------
# Configuración de funciones de recompensa para modelos de peso abierto
Las funciones de recompensa evalúan la calidad de la respuesta y proporcionan señales de retroalimentación para el entrenamiento del modelo. Puede configurar funciones de recompensa mediante funciones Lambda personalizadas. Elija el enfoque que se adapte a los requisitos de su tarea.
## Funciones Lambda personalizadas para la evaluación de recompensas
Puede configurar funciones de recompensa mediante funciones Lambda personalizadas. Dentro de su función Lambda, tiene flexibilidad a la hora de implementar la lógica de evaluación:
+ **Tareas objetivas**: para las tareas objetivas, como la generación de código o el razonamiento matemático, utilice calificadores verificables y basados en reglas que comprueben la corrección comparándola con estándares o casos de prueba conocidos.
+ **Tareas subjetivas**: para tareas subjetivas como el seguimiento de instrucciones o las interacciones con un chatbot, utilice los modelos básicos de Amazon Bedrock como jueces de su función Lambda para evaluar la calidad de la respuesta en función de sus criterios.
La función Lambda puede implementar una lógica compleja, integrar elementos externos APIs, realizar cálculos de varios pasos o combinar varios criterios de evaluación en función de los requisitos de la tarea.
**nota**
Al utilizar funciones Lambda personalizadas:
Aumente el tiempo de espera de Lambda de 3 segundos por defecto a un máximo de 15 minutos para evaluaciones complejas.
La función de ejecución de Lambda necesita permisos para invocar la función Lambda, tal y como se describe en. [Permisos Lambda para funciones de recompensa](rft-open-weight-access-security.md#openai-fine-tuning-lambda-permissions)
## Detalles de implementación de la función Lambda
Al implementar funciones de recompensa de Lambda personalizadas, la función debe aceptar y devolver datos en el siguiente formato.
------
#### [ 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"
}
]
}]
```
------
**Directrices de diseño**
+ **Clasifique las respuestas**: otorgue a la mejor respuesta una puntuación claramente más alta
+ **Utilice controles consistentes**: evalúe la finalización de las tareas, el cumplimiento del formato, la seguridad y la duración razonable
+ **Mantenga una escala estable**: mantenga las puntuaciones normalizadas y que no sean explotables
# Cree y gestione trabajos de ajuste fino para modelos de peso abierto mediante OpenAI APIs
El trabajo de ajuste fino compatible con OpenAI APIs le permite crear, monitorear y administrar trabajos de ajuste fino. En esta página se destaca su uso para afinar los refuerzos. APIs Para obtener información completa sobre la API, consulte la documentación sobre el [OpenAIajuste](https://platform.openai.com/docs/api-reference/fine-tuning) preciso.
## Cree un trabajo de ajuste
Crea un trabajo de ajuste que inicia el proceso de creación de un nuevo modelo a partir de un conjunto de datos determinado. Para obtener información completa sobre la API, consulta la documentación sobre cómo [OpenAIcrear trabajos de ajuste preciso](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/create).
### Ejemplos
Para crear un trabajo de ajuste preciso con el método RFT, elija la pestaña correspondiente al método que prefiera y, a continuación, siga estos pasos:
------
#### [ 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 ]
Haga una solicitud POST a: `/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
}
}
}
}'
```
------
## Enumere los eventos de ajuste
Enumera los eventos para realizar un trabajo de ajuste. Los eventos de ajuste preciso proporcionan información detallada sobre el progreso de su trabajo, incluidas las métricas de formación, la creación de puntos de control y los mensajes de error. Para obtener información completa sobre la API, consulta la documentación de [OpenAIList Fine-Tuning](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list_events) Events.
### Ejemplos
Para ver una lista de los eventos de ajuste preciso, selecciona la pestaña del método que prefieras y, a continuación, sigue estos pasos:
------
#### [ 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 ]
Realiza una solicitud GET a: `/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
```
------
Los eventos incluyen información como:
+ Mensajes de inicio y finalización de la formación
+ Notificaciones de creación de puntos de control
+ Métricas de entrenamiento (pérdida, precisión) en cada paso
+ Mensajes de error si el trabajo falla
Para paginar todos los eventos, elige la pestaña del método que prefieras y, a continuación, sigue estos pasos:
------
#### [ 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 ]
Realiza varias solicitudes GET con el `after` parámetro:
```
# 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"
```
------
## Recupera un trabajo de ajuste
Obtenga información detallada sobre un trabajo de ajuste. Para obtener información completa sobre la API, consulte la documentación sobre los trabajos de [ajuste OpenAI preciso de Retrieve](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/retrieve).
### Ejemplos
Para obtener detalles de un trabajo específico, selecciona la pestaña del método que prefieras y, a continuación, sigue los pasos:
------
#### [ 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 ]
Haga una solicitud GET a`/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"
```
------
## Enumere los trabajos de ajuste
Enumera los trabajos de optimización de su organización con soporte de paginación. Para obtener información completa sobre la API, consulta la documentación de [OpenAIList Fine-Tuning](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list) Jobs.
### Ejemplos
Para ver una lista de los trabajos de ajuste preciso con límite y paginación, selecciona la pestaña correspondiente al método que prefieras y, a continuación, sigue estos pasos:
------
#### [ 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 ]
Haz una solicitud GET a: `/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"
```
------
## Cancela el trabajo de ajuste
Cancela un trabajo de ajuste que está en curso. Una vez cancelado, el trabajo no se puede reanudar. Para obtener información completa sobre la API, consulte la documentación sobre cómo [OpenAIcancelar el trabajo de ajuste detallado.](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/cancel)
### Ejemplos
Para cancelar un trabajo de ajuste, selecciona la pestaña correspondiente al método que prefieras y, a continuación, sigue estos pasos:
------
#### [ 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 ]
Haga una solicitud POST a: `/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"
```
------
## Enumere los puntos de control de ajuste
Enumera los puntos de control para un trabajo de ajuste. Los puntos de control son instantáneas de modelos intermedios que se crean durante el ajuste y que se pueden utilizar como inferencias para evaluar el rendimiento en las diferentes etapas del entrenamiento. [Para obtener más información, consulte la documentación sobre el ajuste preciso de los puntos de control de ListOpenAI.](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/subresources/checkpoints/methods/list)
### Ejemplos
Para ver una lista de los puntos de control necesarios para un trabajo de ajuste, elija la pestaña correspondiente al método que prefiera y, a continuación, siga estos pasos:
------
#### [ 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 ]
Haz una solicitud GET a: `/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
```
------
Cada punto de control incluye:
+ **ID de punto de control**: identificador único del punto de control
+ **Número de paso**: paso de entrenamiento en el que se creó el punto de control
+ **Punto de control del modelo**: identificador del modelo que se puede utilizar para realizar inferencias
+ **Métricas**: pérdida de validación y precisión en este punto de control
Para utilizar un modelo de puntos de control para la inferencia, elija la pestaña correspondiente al método que prefiera y, a continuación, siga los pasos:
------
#### [ 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 ]
Realice una solicitud POST a: `/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
}'
```
------
## Ejecute la inferencia con un modelo ajustado
Una vez que hayas completado el trabajo de ajuste, puedes usar el modelo ajustado para realizar inferencias a través de la API de respuestas o la API de finalización de chats. Para obtener información completa sobre la API, consulte. [Genere respuestas utilizando OpenAI APIs](bedrock-mantle.md)
### API de respuestas
Usa la API de respuestas para generar texto en una sola vuelta con tu modelo ajustado:
------
#### [ 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 ]
Realiza una solicitud POST a: `/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 finalización de chats
Usa la API Chat Completions para interactuar conversacionalmente con tu modelo ajustado:
------
#### [ 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 ]
Realiza una solicitud POST a: `/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
}'
```
------