View a markdown version of this page

Cree y gestione trabajos de ajuste fino para modelos de peso abierto mediante OpenAI APIs - Amazon Bedrock
Cree un trabajo de ajusteEnumere los eventos de ajusteRecupera un trabajo de ajusteEnumere los trabajos de ajusteCancela el trabajo de ajusteEnumere los puntos de control de ajusteEjecute la inferencia con un modelo ajustado

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.

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

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

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

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.

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

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
  }'