View a markdown version of this page

Crea e gestisci lavori di ottimizzazione per modelli open weight utilizzando OpenAI APIs - Amazon Bedrock
Crea un lavoro di messa a puntoElenca gli eventi di ottimizzazioneRecupera il lavoro di messa a puntoElenca i lavori di ottimizzazioneAnnulla il lavoro di messa a puntoElenca i checkpoint di ottimizzazioneEsegui l'inferenza con un modello ottimizzato

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Crea e gestisci lavori di ottimizzazione per modelli open weight utilizzando OpenAI APIs

Il processo di fine-tuning compatibile con OpenAI APIs consente di creare, monitorare e gestire lavori di fine-tuning. Questa pagina illustra come utilizzarli per la messa a punto dei rinforzi. APIs Per i dettagli completi sull'API, consulta la documentazione Fine-tuning. OpenAI

Crea un lavoro di messa a punto

Crea un processo di ottimizzazione che avvia il processo di creazione di un nuovo modello da un determinato set di dati. Per i dettagli completi sull'API, consulta la documentazione OpenAICreate fine-tuning jobs.

Esempi

Per creare un processo di ottimizzazione con il metodo RFT, scegli la scheda relativa al metodo preferito, quindi segui i passaggi:

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

Fai una richiesta 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
        }
      }
    }
  }'

Elenca gli eventi di ottimizzazione

Elenca gli eventi per un lavoro di ottimizzazione. Gli eventi di ottimizzazione forniscono informazioni dettagliate sullo stato di avanzamento del lavoro, tra cui metriche di formazione, creazione di checkpoint e messaggi di errore. Per i dettagli completi sull'API, consulta la documentazione List fine-tuning eventsOpenAI.

Esempi

Per elencare gli eventi di fine-tuning, scegli la scheda corrispondente al tuo metodo preferito, quindi segui i passaggi:

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

Fai una richiesta 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

Gli eventi includono informazioni come:

  • Messaggi di inizio e completamento del corso di formazione

  • Notifiche di creazione di checkpoint

  • Metriche di allenamento (perdita, precisione) in ogni fase

  • Messaggi di errore se il processo fallisce

Per visualizzare tutti gli eventi, scegliete la scheda corrispondente al metodo che preferite, quindi seguite i passaggi:

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

Effettua più richieste GET con il after parametro:

# 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 il lavoro di messa a punto

Ottieni informazioni dettagliate su un lavoro di messa a punto. Per i dettagli completi sull'API, consulta la documentazione OpenAIRetrieve fine-tuning job.

Esempi

Per recuperare dettagli specifici del lavoro, scegli la scheda relativa al metodo che preferisci, quindi segui i passaggi:

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

Fai una richiesta 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"

Elenca i lavori di ottimizzazione

Elenca i lavori di ottimizzazione della tua organizzazione con supporto per l'impaginazione. Per i dettagli completi sull'API, consulta la documentazione OpenAIList fine-tuning jobs.

Esempi

Per elencare i lavori di fine-tuning con limite e paginazione, scegli la scheda corrispondente al metodo che preferisci, quindi segui i passaggi:

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

Effettua una richiesta 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"

Annulla il lavoro di messa a punto

Annulla un processo di messa a punto in corso. Una volta annullato, il lavoro non può essere ripreso. Per i dettagli completi sull'API, consulta la documentazione OpenAIAnnulla il lavoro di fine-tuning.

Esempi

Per annullare un processo di fine-tuning, scegli la scheda corrispondente al metodo che preferisci, quindi segui i passaggi:

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

Invia una richiesta 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"

Elenca i checkpoint di ottimizzazione

Elenca i punti di controllo per un lavoro di messa a punto. I checkpoint sono istantanee intermedie del modello create durante la messa a punto che possono essere utilizzate a fini di inferenza per valutare le prestazioni nelle diverse fasi di addestramento. Per ulteriori informazioni, consulta la documentazione List fine-tuning checkpoint. OpenAI

Esempi

Per elencare i punti di controllo necessari per un lavoro di messa a punto, scegli la scheda corrispondente al metodo che preferisci, quindi segui i passaggi:

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

Effettua una richiesta 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

Ogni checkpoint include:

  • Checkpoint ID: identificatore univoco per il checkpoint

  • Numero della fase: fase di addestramento in cui è stato creato il checkpoint

  • Punto di controllo del modello: identificatore del modello che può essere utilizzato per l'inferenza

  • Metriche: perdita e precisione della convalida a questo punto di controllo

Per utilizzare un modello di checkpoint per l'inferenza, scegli la scheda relativa al metodo preferito, quindi segui i passaggi:

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

Fai una richiesta 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
  }'

Esegui l'inferenza con un modello ottimizzato

Una volta completato il lavoro di ottimizzazione, puoi utilizzare il modello ottimizzato per l'inferenza tramite l'API Responses o l'API Chat Completions. Per i Genera risposte utilizzando OpenAI APIs dettagli completi sull'API, consulta.

API di risposta

Usa l'API Responses per la generazione di testo a turno singolo con il tuo modello ottimizzato:

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

Fai una richiesta 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 per il completamento della chat

Usa l'API Chat Completions per le interazioni conversazionali con il tuo modello ottimizzato:

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

Fai una richiesta 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
  }'