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à.
# Ottimizza i modelli a peso aperto utilizzando -compatible OpenAI APIs
Amazon Bedrock fornisce endpoint API OpenAI compatibili per la messa a punto dei modelli di base. Questi endpoint consentono di utilizzare strumenti familiari per creare, monitorare OpenAI SDKs e gestire lavori di ottimizzazione con i modelli Amazon Bedrock. Questa pagina illustra come utilizzarli per la messa a punto dei rinforzi. APIs
## Funzionalità chiave
+ **Carica file di formazione**: utilizza l'API Files per caricare e gestire i dati di formazione per perfezionare i lavori
+ **Crea lavori di ottimizzazione: inizia a perfezionare i lavori** con dati di formazione personalizzati e funzioni di ricompensa
+ **Elenca e recupera i lavori: visualizza tutti i lavori di** messa a punto e ottieni informazioni dettagliate su lavori specifici
+ Monitora **gli eventi lavorativi: monitora** i progressi di ottimizzazione tramite registri degli eventi dettagliati
+ **Accedi ai checkpoint: recupera i checkpoint del modello intermedio** creati durante la formazione
+ **Inferenza immediata**: una volta completata la messa a punto, utilizza il modello ottimizzato risultante per l'inferenza su richiesta tramite la compatibilità con OpenAI di Amazon Bedrock (API di completamento delle risposte e delle chat) senza passaggi di distribuzione aggiuntivi APIs
+ **Migrazione** sempliceOpenAI: compatibile con le basi di codice SDK esistenti
## Workflow di rinforzo e ottimizzazione per modelli a peso aperto
Prima della messa a punto, assicurati di disporre dei prerequisiti, poiché Amazon Bedrock necessita di autorizzazioni specifiche per creare e gestire il processo di messa a punto. Per informazioni complete su [Accesso e sicurezza per modelli a peso aperto](rft-open-weight-access-security.md) sicurezza e autorizzazioni, consulta.
Esegui la messa a punto del rinforzo per i modelli a peso aperto in 5 passaggi:
1. **Carica il set di dati di addestramento**: utilizza l'API Files per caricare i prompt nel formato richiesto (ad esempio, JSONL) con lo scopo di «perfezionare» il set di dati di addestramento per il perfezionamento dei rinforzi. Per ulteriori informazioni, consulta [Preparare i dati per modelli a peso aperto](rft-prepare-data-open-weight.md).
1. **Configura la funzione Reward**: definisci un classificatore per assegnare un punteggio alle risposte del modello in base a correttezza, struttura, tono o altri obiettivi utilizzando le funzioni Lambda. Per ulteriori informazioni, consulta [Configurazione delle funzioni di ricompensa per i modelli a peso aperto](reward-functions-open-weight.md).
1. **Crea un lavoro di fine-tuning**: avvia il processo di ottimizzazione del rinforzo utilizzando l'API compatibile specificando il modello di base, OpenAI il set di dati, la funzione di ricompensa e altre impostazioni opzionali come gli iperparametri. Per ulteriori informazioni, consulta [Crea un lavoro di messa a punto](fine-tuning-openai-job-create.md#fine-tuning-openai-create-job).
1. Monitora i **progressi della formazione: monitora** lo stato del lavoro, gli eventi e le metriche di formazione utilizzando i processi di ottimizzazione. APIs Per ulteriori informazioni, consulta [Elenca gli eventi di ottimizzazione](fine-tuning-openai-job-create.md#fine-tuning-openai-list-events). Accedi ai checkpoint dei modelli intermedi per valutare le prestazioni nelle diverse fasi della formazione, vedi. [Elenca i checkpoint di ottimizzazione](fine-tuning-openai-job-create.md#fine-tuning-openai-list-checkpoints)
1. **Esegui inferenza**: utilizza l'ID del modello ottimizzato direttamente per l'inferenza tramite le risposte o i completamenti delle chat compatibili con Amazon Bedrock. OpenAI APIs Per ulteriori informazioni, consulta [Esegui l'inferenza con un modello ottimizzato](fine-tuning-openai-job-create.md#fine-tuning-openai-inference).
## Regioni ed endpoint supportati
La tabella seguente mostra i modelli e le regioni di base che supportano la messa a punto OpenAI APIs compatibile:
**Regioni e modelli supportati per una messa a punto compatibile OpenAI APIs**
| Provider | Modello | ID modello | Nome Regione | Regione | Endpoint |
| --- | --- | --- | --- | --- | --- |
| OpenAI | GPT-OSS-20b | apri i.gpt-oss-20b | Stati Uniti occidentali (Oregon) | us-west-2 | bedrock-mantle.us-west-2.api.aws |
| Qwen | Qwen3 32 GB | qwen.qwen3-32b | Stati Uniti occidentali (Oregon) | us-west-2 | bedrock-mantle.us-west-2.api.aws |
# Accesso e sicurezza per modelli a peso aperto
Prima di iniziare il reinforcement fine-tuning (RFT), assicurati di comprendere il tipo di accesso di cui Amazon Bedrock ha bisogno per operazioni specifiche di RFT. RFT richiede autorizzazioni aggiuntive oltre alla regolazione di precisione standard grazie alle sue capacità di esecuzione della funzione di ricompensa.
## Prerequisiti
Prima di utilizzare il fine-tuning OpenAI compatibile con Amazon Bedrock APIs, assicurati di disporre di quanto segue:
1. Un AWS account con le autorizzazioni appropriate per accedere ad Amazon Bedrock
1. **Autenticazione**: puoi autenticarti utilizzando:
+ Chiave API Amazon Bedrock (richiesta per OpenAI SDK e disponibile per le richieste HTTP)
+ AWS credenziali (supportate per le richieste HTTP)
**Nota**
[Se utilizzi chiavi API di Amazon Bedrock a breve/lungo termine, assicurati che il tuo ruolo abbia accesso alle seguenti autorizzazioni delle policy IAM: e al ruolo. `AmazonBedrockMantleFullAccess` AWSLambda](https://docs.aws.amazon.com/bedrock/latest/ug/rft-open-weight-access-security#openai-fine-tuning-lambda-permissions)
1. **OpenAISDK (opzionale)**: installa l'SDK OpenAI Python se utilizzi richieste basate su SDK.
1. Variabili di **ambiente: imposta le seguenti variabili** di ambiente:
+ `OPENAI_API_KEY`— Imposta sulla tua chiave API Amazon Bedrock
+ `OPENAI_BASE_URL`— Impostato sull'endpoint Amazon Bedrock per la tua regione (ad esempio,) `https://bedrock-mantle.us-west-2.api.aws/v1`
Per ulteriori informazioni, consulta [API di risposta](bedrock-mantle.md#bedrock-mantle-responses).
1. **Dati di addestramento** formattati come file JSONL con lo scopo. `fine-tune` Per ulteriori informazioni, consulta [Preparare i dati per modelli a peso aperto](rft-prepare-data-open-weight.md).
## Autorizzazioni Lambda per le funzioni di ricompensa
È necessario aggiungere le autorizzazioni di chiamata Lambda. Di seguito viene illustrato un esempio di policy che è possibile utilizzare:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:*:*:function:reward-function-name"
]
}
]
}
```
Puoi anche utilizzare i modelli ospitati da Amazon Bedrock come giudici per configurare funzioni di ricompensa. Dovrai aggiungere autorizzazioni specifiche per richiamare i modelli di base al ruolo di esecuzione Lambda. Nel tuo ruolo lambda, puoi configurare queste politiche gestite per il grading. LLMs Per informazioni, consulta [AmazonBedrockLimitedAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockLimitedAccess.html).
Di seguito è riportato un esempio di come richiamare i modelli di Amazon Bedrock Foundation come arbitri utilizzando l'API Invoke:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:*:*:foundation-model/*"
]
}
]
}
```
# Preparare i dati per modelli a peso aperto
Quando ottimizzi modelli a peso aperto con la regolazione di precisione dei rinforzi utilizzando la compatibilità con OpenAI APIs, fornisci dati di addestramento inserendo i tuoi prompt in formato JSONL allo scopo. `fine-tune`
## Formato e requisiti dei dati di formazione
I dati di formazione devono seguire il formato di completamento delle chat OpenAI con 100-20.000 esempi. Ogni esempio di formazione contiene:
+ `messages`: In questo campo, includi il ruolo dell'utente, del sistema o dell'assistente contenente il prompt di input fornito al modello.
+ `reference_answer`: In questo campo, deve contenere l'output previsto o i criteri di valutazione utilizzati dalla funzione di ricompensa per assegnare un punteggio alla risposta del modello. Non si limita agli output strutturati, ma può contenere qualsiasi formato che aiuti la funzione di ricompensa a valutare la qualità.
+ [Facoltativo] È possibile aggiungere campi utilizzati da grader Lambda per la valutazione.
**Requisiti:**
+ Formato JSONL con istruzioni nel formato di completamento della chat OpenAI (un prompt per riga)
+ Lo scopo deve essere impostato su `fine-tune`
+ Un minimo di 100 record nel set di dati di addestramento
+ Amazon Bedrock convalida automaticamente il formato del set di dati di addestramento
------
#### [ 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 di file
Puoi utilizzare i file compatibili con OpenAI api per caricare i tuoi dati di allenamento per lavori di ottimizzazione. I file vengono archiviati in modo sicuro in Amazon Bedrock e vengono utilizzati per creare lavori di ottimizzazione. [Per informazioni complete sull'API, consulta la documentazione di Files. OpenAI](https://platform.openai.com/docs/api-reference/files)
### Carica il file di allenamento
Per caricare un file di allenamento, 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()
# 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 ]
Invia una richiesta 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"
```
------
### Recupera i dettagli del file
Per recuperare i dettagli su un file specifico, 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()
# 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 ]
Fai una richiesta 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"
```
------
### Elenca i file
Per elencare i file caricati, 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 files
files_response = client.files.list(purpose='fine-tune')
# Print raw response
print(json.dumps(files_response.model_dump(), indent=2))
```
------
#### [ HTTP request ]
Effettua una richiesta GET a`/v1/files`:
```
curl https://bedrock-mantle.us-west-2.api.aws/v1/files?purpose=fine-tune \
-H "Authorization: Bearer $OPENAI_API_KEY"
```
------
### Elimina file
Per eliminare un file, scegli la scheda corrispondente 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()
# Delete file
delete_response = client.files.delete(training_file_id)
```
------
#### [ HTTP request ]
Effettua una richiesta DELETE 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"
```
------
## Caratteristiche dei dati di allenamento efficaci
Dati di addestramento RFT efficaci richiedono tre caratteristiche chiave:
+ **Chiarezza e coerenza**: utilizza istruzioni chiare e inequivocabili con una formattazione coerente. Evita etichette contraddittorie, istruzioni ambigue o risposte di riferimento contrastanti che fuorviano la formazione.
+ **Diversità**: includi diversi formati di input, casi limite e livelli di difficoltà che riflettono i modelli di utilizzo della produzione in diversi tipi di utenti e scenari.
+ **Funzioni di ricompensa efficienti**: progetta funzioni che vengano eseguite rapidamente (secondi, non minuti), parallelizzino e restituiscano AWS Lambda punteggi costanti per una formazione conveniente.
## Proprietà aggiuntive
Il formato di dati RFT supporta campi personalizzati oltre ai requisiti di base dello schema (e). `messages` `reference_answer` Questa flessibilità consente di aggiungere tutti i dati aggiuntivi necessari alla funzione di ricompensa per una corretta valutazione.
**Nota**
Non è necessario configurarlo nella ricetta. Il formato dei dati supporta intrinsecamente campi aggiuntivi. Basta includerli nei dati di allenamento JSON e verranno passati alla funzione di ricompensa sul campo. `metadata`
**Proprietà aggiuntive comuni**
+ `task_id`— Identificatore univoco per il tracciamento
+ `difficulty_level`— Indicatore di complessità del problema
+ `domain`— Area o categoria tematica
+ `expected_reasoning_steps`— Numero di passaggi della soluzione
Questi campi aggiuntivi vengono trasferiti alla funzione di ricompensa durante la valutazione, abilitando una sofisticata logica di punteggio personalizzata in base al caso d'uso specifico.
**Esempi con proprietà aggiuntive**
------
#### [ 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
}
}
```
Il `reference_answer` campo contiene l'output previsto o i criteri di valutazione utilizzati dalla funzione di ricompensa per assegnare un punteggio alla risposta del modello. Non si limita agli output strutturati, ma può contenere qualsiasi formato che aiuti la funzione di ricompensa a valutare 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
}
```
------
# Configurazione delle funzioni di ricompensa per i modelli a peso aperto
Le funzioni di ricompensa valutano la qualità della risposta e forniscono segnali di feedback per l'addestramento dei modelli. Puoi configurare funzioni di ricompensa utilizzando funzioni Lambda personalizzate. Scegliete l'approccio più adatto ai requisiti della vostra attività.
## Funzioni Lambda personalizzate per la valutazione dei premi
Puoi configurare funzioni di ricompensa utilizzando funzioni Lambda personalizzate. All'interno della funzione Lambda, hai flessibilità nel modo in cui implementi la logica di valutazione:
+ **Attività oggettive: per attività** oggettive come la generazione di codice o il ragionamento matematico, utilizza classificatori verificabili basati su regole che controllano la correttezza rispetto a standard o casi di test noti.
+ Attività **soggettive: per attività** soggettive come seguire istruzioni o interagire con i chatbot, chiama i modelli di base di Amazon Bedrock come giudici all'interno della tua funzione Lambda per valutare la qualità della risposta in base ai tuoi criteri.
La tua funzione Lambda può implementare logiche complesse, integrare elementi esterni APIs, eseguire calcoli in più fasi o combinare più criteri di valutazione a seconda dei requisiti dell'attività.
**Nota**
Quando si utilizzano funzioni Lambda personalizzate:
Aumenta il timeout Lambda dal valore predefinito di 3 secondi a un massimo di 15 minuti per valutazioni complesse.
Il ruolo di esecuzione Lambda necessita delle autorizzazioni per richiamare la funzione Lambda come descritto in. [Autorizzazioni Lambda per le funzioni di ricompensa](rft-open-weight-access-security.md#openai-fine-tuning-lambda-permissions)
## Dettagli sull'implementazione della funzione Lambda
Quando si implementano funzioni di ricompensa Lambda personalizzate, la funzione deve accettare e restituire dati nel seguente 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"
}
]
}]
```
------
**Linee guida di progettazione**
+ **Classizza le risposte**: assegna alla risposta migliore un punteggio chiaramente più alto
+ **Utilizza controlli coerenti**: valuta il completamento delle attività, la conformità al formato, la sicurezza e la durata ragionevole
+ **Mantieni una scalabilità stabile: mantieni i** punteggi normalizzati e non sfruttabili
# 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](https://platform.openai.com/docs/api-reference/fine-tuning)
## 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](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/create) 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.](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list_events)
### 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](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/retrieve) 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](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/list) 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](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/methods/cancel).
### 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](https://developers.openai.com/api/reference/resources/fine_tuning/subresources/jobs/subresources/checkpoints/methods/list)
### 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](bedrock-mantle.md) 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
}'
```
------