Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Iterācija: kad atkārtoti pielāgot modeli

Nodarbība 13 no 16 Atjaunota 2026. gada 2. novembris Augstākais
Šajā lapā
  1. Modeļa pielāgošana ir iteratīvs process
  2. Analizē kļūdas pirms to labošanas
  3. Kad ir jāveic iterācija
  4. Bagātini, nevis sāc no nulles
  5. Nepārtraukta modeļa pielāgošana un tās robežas
  6. Pilns cikls
  7. Dokumentē katru iterāciju
  8. Galvenās atziņas

Atjauninājums, 2026. gada 2. novembris — Modeļu pielāgošanas pieejamība. OpenAI pašapkalpošanās modeļu pielāgošanas pakalpojums tiek pakāpeniski izbeigts: kopš 2026. gada 7. maija organizācijas, kas nekad nav veikušas pielāgošanas uzdevumu, vairs nevar tādu izveidot; kopš 2. jūlija ir jābūt izmantojušam pielāgotu modeli pēdējo 60 dienu laikā; un sākot ar 2027. gada 6. janvāri, neviens klients vairs nevarēs uzsākt jaunus uzdevumus. Jau apmācīti modeļi paliek lietojami, līdz tiek izņemta to bāzes modeļa versija. Šis kurss joprojām ir noderīgs, lai izprastu un izmantotu esošu modeli; jauniem projektiem prioritāte ir promptu inženierija, RAG un novērtēšana.

Modeļa pielāgošana ir iteratīvs process

Tavs pirmais modeļa pielāgošanas mēģinājums reti kad būs ideāls. Uzlabojumi rodas no iteratīviem cikliem: analizē kļūdas, bagātini datus, apmāci modeli no jauna un atkārtoti novērtē rezultātus. Šī nodarbība iemācīs tev noteikt, kad un kā efektīvi veikt iterācijas, un, tikpat svarīgi, kā atpazīt situācijas, kurās atkārtota apmācība būtu bezjēdzīga.

Analizē kļūdas pirms to labošanas

Dabiskais instinkts pēc viltus novērtējuma ir nejauši pievienot piemērus, cerot, ka apjoms atrisinās problēmu. Tas ir ātrākais veids, kā iztērēt apmācības budžetu, nepanākot progresu. Sāc ar to, ka katru neveiksmi iedali kategorijā: nepareizs formāts, neatbilstošs tonis, faktiska kļūda, nepilnīga atbilde, atbilde ne par tēmu vai tīra halucinācija. Iegūtais sadalījums norāda, kur koncentrēt pūles, un bieži vien atklāj pārsteigumu — tas, ko uzskatīji par stila problēmu, izrādās pilnīguma trūkums.

def analyze_errors(results: list[dict]) -> dict:
    """Categorizes errors from the fine-tuned model."""
    categories = {
        "format": [],       # Incorrect response format
        "tone": [],         # Inappropriate tone
        "factual": [],      # Incorrect information
        "incomplete": [],   # Response too short or missing elements
        "off_topic": [],    # Does not answer the question
        "hallucination": [] # Invents information
    }

    for r in results:
        if r.get("score", 5) < 3:
            # Classify the error (can be done manually or by an LLM)
            category = classify_error(r)
            categories[category].append(r)

    print("Error distribution:")
    for cat, errors in categories.items():
        if errors:
            print(f"  {cat}: {len(errors)} cases")

    return categories

Tālāk apskati gadījumus vienā kategorijā, lai atrastu kopīgu saucēju. Uzdev sev vienus un tos pašus jautājumus: vai modelis kļūdas pieļauj konkrēta veida jautājumos, vai kļūdas grupējas ap noteiktām tēmām un vai problēma slēpjas datos vai hiperparametros? Kļūdas, kas izkliedētas pa visām tēmām, bet vienmēr ir viena rakstura, norāda uz piemēru trūkumu; kļūdas, kas koncentrētas vienā jomā, liecina par pārklājuma trūkumu; un atbildes, kas pārāk cieši pieturas pie apmācības piemēriem neatkarīgi no jautājuma, signalizē par pārmācīšanos (overfitting), kas jālabo, pielāgojot epohu skaitu.

Kad ir jāveic iterācija

Noteiktas pazīmes nepārprotami liecina, ka nepieciešama jauna versija, un katrai no tām ir vajadzīga atšķirīga pieeja. Modeli, kas halucinē par kādu tēmu, nevar izlabot, rādot tam vairāk pareizu atbilžu par šo tēmu, bet gan iemācot tam pieklājīgi atteikties, kad tas nezina atbildi.

SignālsDarbība
Atkārtotas formāta kļūdasPievieno vairāk piemēru ar pareizo formātu
Modelis halucinē par noteiktām tēmāmPievieno piemērus, kur tas pieklājīgi atsakās atbildēt
Konstatēta pārmācīšanās (overfitting)Samazini epohu skaitu, dažādo datus
Jauni lietojuma gadījumi, kas jāaptverPievieno piemērus šiem gadījumiem
Mērķtiecīga negatīva lietotāju atsauksmePārvērt atsauksmes labotos piemēros

Turpretī vairākas situācijas tev attur no atkārtotas apmācības. Ja kļūdas ir retas un nesistemātiskas, prompta pielāgošana tās atrisinās ātrāk un lētāk. Ja sūdzības attiecas uz latentumu vai gaidīšanas laiku, problēma slēpjas tavā infrastruktūrā, un nekāda apmācība to neizlabos. Ja kopš pēdējās versijas esi savācis tikai dažus jaunus piemērus, paredzamais ieguvums neatmaksās uzdevuma izmaksas. Un, kad kļūst pieejams jauns bāzes modelis, vispirms to iztestē tādu, kāds tas ir: reizēm tas pats par sasniedz to, ko tava iepriekšējā versija ar grūtībām mēģināja nodrošināt.

Bagātini, nevis sāc no nulles

Inkrementāla iterācija nozīmē mērķtiecīgu piemēru pievienošanu esošajam datu kopumam, nepieskaroties pārējiem. Šī ir visbiežāk sastopamā un vienkāršākā darbība: tu ielādē pašreizējo failu, apvieno jaunos gadījumus un visu pārraksti JSONL formātā. Galīgais skaits kalpo kā kontrole — ja kopsumma nesakrīt ar paredzamo, tas norāda uz faila nolasīšanas kļūdu vai zaudētām rindām.

import json

def enrich_dataset(
    existing_dataset: str,
    new_examples: list[dict],
    output: str
):
    """Adds new examples to the existing dataset."""
    # Load existing data
    with open(existing_dataset, "r") as f:
        existing = [json.loads(l) for l in f]

    # Merge
    combined = existing + new_examples

    # Save
    with open(output, "w") as f:
        for ex in combined:
            f.write(json.dumps(ex, ensure_ascii=False) + "\n")

    print(f"Enriched dataset: {len(existing)} + {len(new_examples)} = {len(combined)}")

Korektīvā iterācija ir vēl vērtīgāka, jo tā pārvērš tavas kļūdas izejvielā. Katra ražošanā atklāta kļūda nodrošina reālu jautājumu; tev tikai jāuzraksta atbilde, kuru būtu vēlējies redzēt, un pāris kļūst par apmācības piemēru. Ņem vērā, ka sliktā atbilde netiek iekļauta gala piemērā: tā palīdz dokumentēt gadījumu un izlemt, vai labojums ir vērts pūles, taču modelis mācās tikai no pareizās versijas.

def error_to_example(
    question: str,
    bad_response: str,
    good_response: str,
    system_msg: str
) -> dict:
    """Transforms an error into a training example."""
    return {
        "messages": [
            {"role": "system", "content": system_msg},
            {"role": "user", "content": question},
            {"role": "assistant", "content": good_response}
        ]
    }

# Transform a batch of errors
corrections = []
for error in detected_errors:
    correction = error_to_example(
        question=error["question"],
        bad_response=error["model_response"],
        good_response=error["corrected_response"],
        system_msg=SYSTEM_PROMPT
    )
    corrections.append(correction)

Nepārtraukta modeļa pielāgošana un tās robežas

Nekas neliedz pielāgot jau iepriekš pielāgotu modeli: vienkārši parametra model vietā norādi tā pilno ID, nevis bāzes modeļa nosaukumu. Šī darbība ir vilinoša, jo tā apmāca modeli tikai uz jaunajiem datiem.

# Fine-tune from an already fine-tuned model
job_v2 = client.fine_tuning.jobs.create(
    training_file=new_file.id,
    model="ft:gpt-5.6-luna:org::suffix-v1:xxxxxxxx",  # v1 model as base
    suffix="my-assistant-v2"
)

Brīdinājums: nepārtraukta modeļa pielāgošana uzkrāj novirzes (bias). Pēc 2–3 secīgām iterācijām bieži vien ir labāk sākt no jauna ar bāzes modeli, izmantojot pilnīgu, bagātinātu datu kopu. Katrs slānis pastiprina iepriekšējā slāņa īpatnības, tostarp tās, kuras neesi paredzējis, un rezultātā modelis sāk reaģēt ar stingrību, ko neviens tam nav tieši mācījis.

Pilns cikls

Zemāk minētie soļi veido cilpu, ko atkārtosi katrā versijā. Ja vispirms risināsi visbiežāk sastopamās kļūdas, nākamajā versijā testa kopā būs vērojams izmērāms uzlabojums; ja risināsi tās nepareizā secībā, iegūsi tikai izkliedētus uzlabojumus, kurus būs grūti pamatot savai komandai.

1

Vāc kļūdas

Identificē gadījumus, kad modelis kļūdās ražošanā vai novērtēšanas laikā.

2

Kategorizē un nosaki prioritātes

Klasificē kļūdas pēc veida un vispirms risini biežāk sastopamās.

3

Izveido korektīvus piemērus

Pārvērt katru kļūdu apmācības piemērā ar pareizu atbildi.

4

Apmāci no jauna un atkārtoti novērtē

Apmāci jauno versiju un salīdzini to ar iepriekšējo, izmantojot to pašu testa kopu.

Dokumentē katru iterāciju

Pēc četrām vai piecām versijām neviens vairs neatceras, ar ko v2 atšķīrās no v3 vai kāpēc v4 tika pamesta. Sistemātiska katra uzdevuma fiksēšana — datu kopas sastāvs, jauno piemēru avots, hiperparametri, rezultāti un pieņemtais lēmums — nodrošina šo informāciju brīdī, kad regresija liek tev atgriezties pie iepriekšējiem soļiem. Pievērs īpašu uzmanību jauno piemēru avotam: tikai tas pēc mēnešiem pateiks, vai pasliktināšanās radusies no slikti izvēlētas datu partijas.

iteration_log = {
    "version": "v3",
    "date": "2026-04-02",
    "base_model": "gpt-5.6-luna",
    "dataset": {
        "train": 350,
        "validation": 45,
        "new_examples": 50,
        "new_examples_source": "production errors week 12"
    },
    "hyperparameters": {
        "n_epochs": 3,
        "learning_rate_multiplier": "auto",
        "batch_size": "auto"
    },
    "results": {
        "validation_loss": 0.42,
        "precision_test": 0.91,
        "avg_csat": 4.3,
        "improvement_vs_v2": "+5% precision, +0.2 CSAT"
    },
    "decision": "Deployed to production on 2026-04-03"
}

Galvenās atziņas

  • Modeļa pielāgošana ir iteratīva — plāno vairākus ciklus
  • Pirms kļūdu labošanas datos, tās vispirms kategorizē
  • Pārvērt lietotāju atsauksmes apmācības piemēros
  • Pēc 2–3 secīgām iterācijām sāc no jauna ar bāzes modeli
  • Dokumentē katru iterāciju, lai saglabātu skaidru vēsturi