Starta finjustering via API:t
På denna sida
Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningslösning för finjustering avvecklas: från och med den 7 maj 2026 kan organisationer som aldrig har kört ett finjusteringsjobb inte längre skapa ett; sedan den 2 juli måste du ha använt en finjusterad modell inom de senaste 60 dagarna; och från och med den 6 januari 2027 kommer ingen kund att kunna starta nya jobb. Redan tränade modeller går att använda tills deras basmodell tas ur bruk. Denna kurs är fortfarande användbar för att förstå och utnyttja en befintlig modell; för nya projekt bör du prioritera prompt engineering, RAG och utvärderingar.
Översikt över processen
Dina data är redo, validerade och uppdelade i tränings- och valideringsset. Själva träningssteget kokar ner till tre moment: ladda upp din datafil, skapa ett finjusteringsjobb och vänta tills träningen är klar. Allt sker via det officiella Python SDK:t, och du kommer att se att koden ryms på cirka trettio rader – det mesta av jobbet har redan gjorts i tidigare steg.
Installera och konfigurera SDK:t
Klienten instansieras utan argument: den läser automatiskt miljövariabeln OPENAI_API_KEY.
# Installation
# pip install openai
from openai import OpenAI
# Klienten använder automatiskt miljövariabeln OPENAI_API_KEY
client = OpenAI()
Se till att denna variabel är satt innan du kör skriptet, annars misslyckas instansieringen vid första förfrågan. I produktion får du aldrig hårdkoda din nyckel i koden: en nyckel som står i klartext hamnar i Git-historiken, och att ta bort den i efterhand är betydligt dyrare än att läsa in den från miljön från dag ett.
Ladda upp filer
Uppladdningen använder purpose="fine-tune", vilket talar om för OpenAI att filen är avsedd för träning och utlöser motsvarande formatkontroller. Ladda upp valideringsfilen direkt: den är tekniskt sett valfri, men utan den kör träningen blindt eftersom ingen valideringsförlust signalerar överanpassning medan jobbet pågår.
# Ladda upp träningsfil
training_file = client.files.create(
file=open("training_data.jsonl", "rb"),
purpose="fine-tune"
)
print(f"Fil-ID: {training_file.id}")
print(f"Status: {training_file.status}")
# Valfritt: ladda upp valideringsfil
validation_file = client.files.create(
file=open("validation_data.jsonl", "rb"),
purpose="fine-tune"
)
print(f"Validerings-ID: {validation_file.id}")
Filen går igenom en bearbetningsfas på OpenAIs sida. Vänta tills statusen är processed innan du startar jobbet: ett jobb som skapas för en fil som fortfarande bearbetas kommer att misslyckas, och du kommer att slösa några minuter på att jaga en icke-existerande orsak i din JSONL.
Skapa finjusteringsjobbet
job = client.fine_tuning.jobs.create(
training_file=training_file.id,
validation_file=validation_file.id, # valfritt men rekommenderas
model="gpt-5.6-luna", # eller "gpt-5.6-luna"
suffix="my-assistant-v1" # suffix för att identifiera din modell
)
print(f"Jobb-ID: {job.id}")
print(f"Status: {job.status}")
print(f"Basmodell: {job.model}")
Parametern suffix läggs till i slutet av namnet på din finjusterade modell: med "my-assistant-v1" kommer den resulterande modellen att heta ft:gpt-5.6-luna:your-org::my-assistant-v1:xxxxxxxx. Vänj dig vid att ange användningsfall och versionsnummer där. Den dag tre modeller samexisterar i ditt konto är det enda sättet att veta vilken som gör vad utan att öppna konsolen.
Följ framdriften
Ett jobb passerar genom flera statusar i sekvens, och retrieve ger dig den aktuella statusen när som helst.
# Hämta jobbstatus
job = client.fine_tuning.jobs.retrieve(job.id)
print(f"Status: {job.status}")
# Möjliga statusar: validating_files, queued, running, succeeded, failed, cancelled
Statusen i sig är lakonisk. Händelserna däremot berättar hela historien: filvalidering, start, stegvis framdrift, slut.
# Visa jobbhändelser
events = client.fine_tuning.jobs.list_events(
fine_tuning_job_id=job.id,
limit=20
)
for event in events.data:
print(f"[{event.created_at}] {event.message}")
Istället för att manuellt anropa retrieve var femte minut, kapsla in väntan i en loop som återlämnar kontrollen så snart jobbet når ett slutläge. Observera att de tre avslutningsfallen hanteras separat: ett avbrutet jobb är inte ett misslyckat jobb, och du vill skilja dem åt i dina loggar.
import time
def track_job(client: OpenAI, job_id: str, interval: int = 30):
"""Spårar ett finjusteringsjobb tills det är klart."""
while True:
job = client.fine_tuning.jobs.retrieve(job_id)
print(f"Status: {job.status}")
if job.status == "succeeded":
print(f"Finjusterad modell: {job.fine_tuned_model}")
return job
if job.status == "failed":
print(f"Misslyckande: {job.error}")
return job
if job.status == "cancelled":
print("Jobbet avbrutet.")
return job
time.sleep(interval)
# Användning
final_job = track_job(client, job.id)
Använd den finjusterade modellen
När jobbet har slutförts framgångsrikt anropas din modell exakt som en standardmodell. Endast värdet som skickas till model ändras, vilket innebär att bytet till din anpassade modell i en befintlig applikation kokar ner till att modifiera en konfigurationsvariabel.
response = client.responses.create(
model=final_job.fine_tuned_model, # t.ex. "ft:gpt-5.6-luna:org::suffix:xxxxxxxx"
input="Hej, jag har ett problem med min beställning."
)
print(response.output_text)
Hantera dina jobb
Två anrop räcker för att administrera allt: lista vad som finns och avbryt det som pågår. Avbrott är användbart så snart övervakningen visar att träningen spårar ur – det finns ingen poäng med att betala för tokens från ett jobb som du redan vet kommer att producera en dålig modell.
# Lista alla dina finjusteringsjobb
jobs = client.fine_tuning.jobs.list(limit=10)
for j in jobs.data:
print(f"{j.id} | {j.status} | {j.model} | {j.fine_tuned_model}")
# Avbryt ett pågående jobb
client.fine_tuning.jobs.cancel(job.id)
Kostnader och varaktighet
Träning debiteras efter antalet bearbetade tokens. Varaktigheten beror däremot på storleken på dina data och antalet epoch.
| Datasetstorlek | Träningsvaraktighet |
|---|---|
| 50 exempel | Några minuter |
| 500 exempel | 15 till 30 minuter |
| 5 000 exempel | 1 till 2 timmar |
Dessa storleksordningar hjälper dig främst att dimensionera din arbetscykel: vid några minuter per körning itererar du i samma session; vid två timmar planerar du. Exakta priser varierar beroende på vald modell; kontrollera OpenAIs prissida för aktuella taxa.
Viktiga punkter
- Arbetsflödet är: ladda upp fil, skapa jobb, vänta, använd modellen
- Lägg till ett beskrivande
suffixför att enkelt identifiera dina modeller - Använd alltid en valideringsfil för att utvärdera kvaliteten
- Den finjusterade modellen används exakt som basmodellen via API:t
- Behåll dina jobb- och modell-ID:n – du behöver dem för versionshantering