Fino podešavanje modela 20 min čitanja

Fino podešavanje velikih jezičnih modela u 2026: Od pripreme podataka do produkcije

Praktični vodič za fino podešavanje velikih jezičnih modela u 2026. Obuhvaća LoRA, QLoRA, pripremu podataka, evaluaciju i produkcijsku primjenu — s konkretnim primjerima koda za Hugging Face i OpenAI ekosustave.

Editorial Team

Uvod: Zašto fino podešavanje mijenja pravila igre

Veliki jezični modeli (LLM) poput GPT-5.2, Claude Opus 4.5 i Llama 3.3 nevjerojatno su sposobni „iz kutije" — odgovaraju na opća pitanja, pišu kod, prevode jezike i analiziraju tekst. No, kad vam treba model koji zaista razumije specifičnu terminologiju vaše domene, dosljedno slijedi vaš format izlaza ili se ponaša prema internim politikama organizacije, opći modeli jednostavno nisu dovoljni. Tu na scenu stupa fino podešavanje (engl. fine-tuning).

Ukratko, fino podešavanje je nastavak treniranja prethodno naučenog modela na ciljnom skupu podataka kako bi se poboljšale performanse za specifični zadatak. Umjesto da trenirate od nule — što zahtijeva ogromne resurse i mjesece rada — iskorištavate postojeće znanje modela i prilagođavate ga vašim potrebama.

Zamislite to ovako: opći LLM je poput izuzetno obrazovane osobe koja zna pomalo o svemu, ali fino podešavanje je specijalizacija. Pretvarate generalista u stručnjaka za vašu konkretnu domenu.

Istraživanja dosljedno pokazuju da fino podešani modeli na domenski specifičnim zadacima nadmašuju opće modele za 15% do 40% u točnosti — čak i kad se opći modeli koriste s naprednim tehnikama promptiranja. Za organizacije koje obrađuju tisuće zahtjeva dnevno, ta razlika znači mjerljivo poboljšanje kvalitete usluge, niže troškove i veću pouzdanost sustava.

U ovom članku vodimo vas kroz cijeli proces — od razumijevanja kad koristiti fino podešavanje, preko pripreme podataka, praktične implementacije s LoRA i QLoRA tehnikama, do evaluacije i produkcijske primjene. Svaki korak popraćen je primjerima koda koje možete odmah primijeniti. Hajdemo, onda.

Kad koristiti fino podešavanje: Odluka koja štedi vrijeme i novac

Prije nego što uložite resurse u fino podešavanje, ključno je razumjeti kad je to uopće pravi pristup. Postoje tri glavne strategije za prilagodbu LLM-ova, i svaka ima svoje mjesto.

Inženjering promptova

Najjednostavniji pristup — oblikujete upute i kontekst koji šaljete modelu. Idealan je kad trebate brze rezultate bez ikakvih troškova treniranja. Doduše, ograničen je veličinom kontekstnog prozora i ne može fundamentalno promijeniti ponašanje modela. Koristite ga kao prvi korak — ako promptiranje daje zadovoljavajuće rezultate, nema potrebe za složenijim pristupima.

RAG (Retrieval-Augmented Generation)

RAG kombinira LLM s vanjskom bazom znanja. Idealan je kad trebate pristup aktualnim, dinamičnim podatcima — recimo dokumentacija proizvoda, interne baze znanja ili pravni dokumenti. Važno je razumjeti da RAG ne mijenja ponašanje modela, nego mu daje pristup relevantnim informacijama u trenutku generiranja odgovora.

Fino podešavanje

Pravi izbor kad trebate:

  • Domensku ekspertizu — model koji razumije medicinsku, pravnu ili financijsku terminologiju na razini stručnjaka
  • Specifičan stil ili format — dosljedno generiranje strukturiranih izlaza, poštivanje internog tona komunikacije
  • Smanjenje latencije i troškova — manji fino podešani model koji zamjenjuje veći opći model
  • Ponašanje koje se ne može postići promptiranjem — duboka prilagodba modela koja nadilazi mogućnosti kontekstnog učenja

Iskreno, u praksi najuspješniji produkcijski sustavi kombiniraju sve tri strategije: fino podešani model optimiziran za domenu, RAG za pristup aktualnim podatcima i pažljivo dizajnirane promptove za kontrolu izlaza. Tek ta kombinacija daje punu sliku.

Metode finog podešavanja: Od potpunog do parametarski učinkovitog

Razumijevanje različitih metoda finog podešavanja ključno je za odabir pravog pristupa. Svaka metoda nosi različite zahtjeve za resursima, razinu kvalitete i složenost implementacije.

Potpuno fino podešavanje (Full Fine-Tuning)

U potpunom finom podešavanju ažurirate sve parametre modela. Za model sa 7 milijardi parametara, to zahtijeva 100–120 GB VRAM-a — dakle višestruke GPU-ove visokog kapaciteta. Rezultati su općenito najbolji, ali rizici su značajni: katastrofalno zaboravljanje (model gubi opće znanje), pretreniranje na malom skupu podataka i enormni računalni troškovi.

Za većinu praktičnih scenarija, potpuno fino podešavanje jednostavno više nije preporučeni pristup.

Nadzirano fino podešavanje (Supervised Fine-Tuning — SFT)

SFT koristi parove uputa i odgovora za učenje modela kako da odgovara na specifične zadatke. Ovo je najčešća metoda post-treniranja i temelj za većinu fino podešanih modela u produkciji. Format podataka je prilično jednostavan — svaki primjer sadrži ulaz (prompt) i očekivani izlaz (odgovor).

LoRA (Low-Rank Adaptation)

LoRA je tehnika koja je, bez pretjerivanja, demokratizirala fino podešavanje. Umjesto ažuriranja svih parametara, LoRA zamrzava izvorne težine modela i ubacuje male trenabilne matrice nižeg ranga u transformerske slojeve. Rezultat? Trenirate samo 0,1% do 1% ukupnih parametara, uz zadržavanje 90–95% kvalitete potpunog finog podešavanja.

Ključni hiperparametri LoRA-e:

  • r (rang) — dimenzija manjih matrica (tipično 8, 16 ili 32). Viši rang znači veći kapacitet, ali i više memorije
  • lora_alpha — faktor skaliranja koji kontrolira utjecaj LoRA adaptora (obično 2× rang)
  • lora_dropout — stopa ispuštanja za regularizaciju (0,05–0,1)
  • target_modules — slojevi u koje se ubacuju LoRA matrice (q_proj, v_proj, k_proj i dr.)

QLoRA (Quantized LoRA)

QLoRA kombinira LoRA s agresivnom kvantizacijom baznog modela na 4 bita, čime dodatno smanjuje memorijske zahtjeve za čak 75%. Tri inovacije čine QLoRA posebnom:

  • 4-bitna NormalFloat kvantizacija — komprimira težine baznog modela na 4 bita
  • Dvostruka kvantizacija — kvantizira i same konstante kvantizacije, štedeći dodatnu memoriju
  • Paginirani optimizatori — prebacuju stanja optimizatora na CPU memoriju tijekom memorijskih skokova

Praktični učinak je impresivan: model sa 70 milijardi parametara, koji bi inače zahtijevao 4–8 GPU-ova, može se fino podesiti na jednom GPU-u s 80 GB VRAM-a. A model sa 7 milijardi parametara? RTX 4090 s 24 GB sasvim je dovoljan.

RLHF i DPO: Usklađivanje s ljudskim preferencijama

RLHF (Reinforcement Learning from Human Feedback) koristi nagradno modeliranje i pojačano učenje za usklađivanje modela s ljudskim preferencijama. Složen je za implementaciju jer zahtijeva treniranje zasebnog nagradnog modela — što nije mala stvar.

DPO (Direct Preference Optimization) elegantno pojednostavljuje RLHF eliminirajući potrebu za nagradnim modelom. Umjesto toga, izravno optimizira model koristeći parove preferiranih i nepreferiranih odgovora. OpenAI je 2025. godine dodao podršku za DPO fino podešavanje za modele GPT-4.1 obitelji, što ga čini pristupačnijim nego ikad.

Destilacija znanja (Knowledge Distillation)

Destilacija prenosi znanje iz velikog „učiteljskog" modela (npr. GPT-5.2) u manji „učenički" model (npr. Phi-4 ili Llama 3.3 8B). Rezultat su kompaktni modeli s performansama bliskima velikim modelima, ali uz znatno niže troškove inferencije. OpenAI je ovu funkcionalnost integrirao izravno u svoju platformu, što cijeli proces čini puno jednostavnijim.

Priprema podataka: Temelj svakog uspješnog finog podešavanja

Ako iz ovog članka ponesete samo jednu stvar, neka bude ova: kvaliteta podataka ima daleko veći utjecaj na rezultate od bilo kojeg drugog faktora — uključujući izbor modela ili hiperparametera. Pravilo palca je jednostavno: 1.000 izvrsnih primjera nadmašuje 10.000 osrednjih.

Format podataka: JSONL kao standard

JSONL (JSON Lines) je dominantni format za podatke finog podešavanja. Svaki redak sadrži jedan primjer treniranja. U praksi se koriste dva glavna formata.

Instrukcijski format (Alpaca stil):

{"instruction": "Klasificiraj sentiment ove recenzije proizvoda.", "input": "Laptop je izvrstan za programiranje, ali baterija traje samo 3 sata.", "output": "Mješovit sentiment. Pozitivno: performanse za programiranje. Negativno: kratko trajanje baterije."}
{"instruction": "Sažmi ovaj pravni tekst u jednu rečenicu.", "input": "Ugovorom se definiraju obveze obiju strana...", "output": "Ugovor obvezuje obje strane na ispunjenje financijskih i operativnih uvjeta unutar 90 dana."}

Chat format (ShareGPT stil):

{"messages": [
  {"role": "system", "content": "Ti si stručnjak za analizu financijskih izvješća."},
  {"role": "user", "content": "Analiziraj prihode tvrtke za Q3 2025."},
  {"role": "assistant", "content": "Na temelju dostavljenih podataka, prihodi u Q3 2025. iznose..."}
]}
{"messages": [
  {"role": "system", "content": "Ti si stručnjak za analizu financijskih izvješća."},
  {"role": "user", "content": "Usporedi profitne marže s prethodnim kvartalom."},
  {"role": "assistant", "content": "Profitna marža u Q3 iznosi 12,3%, što predstavlja rast od 2,1 postotni bod..."}
]}

Smjernice za kvalitetu podataka

Na temelju iskustva i najboljih praksi, evo ključnih smjernica za pripremu podataka:

  1. Raznolikost primjera — pokrijte različite scenarije, rubne slučajeve i razine složenosti. Ako model vidi samo jednostavne primjere, teško će generalizirati na složenije zadatke.
  2. Konzistentnost formata — svi primjeri moraju slijediti isti format izlaza. Ako očekujete JSON, svaki primjer mora sadržavati valjani JSON odgovor. Bez iznimki.
  3. Točnost sadržaja — svaki odgovor u skupu podataka mora biti faktički točan. Model će naučiti reproducirati pogreške jednako kao i ispravne odgovore (što je pomalo zastrašujuće kad malo razmislite).
  4. Optimalna duljina — odgovori trebaju biti dovoljno detaljni da budu korisni, ali ne nepotrebno dugački. Predugi odgovori povećavaju troškove treniranja bez proporcionalnog poboljšanja kvalitete.
  5. Čišćenje podataka — uklonite duplikate, primjere s pogreškama, nedosljedne formate i nekvalitetne parove. Automatske provjere (validacija JSON-a, provjera duljine, detekcija duplikata) trebale bi biti dio vašeg cjevovoda.

Generiranje sintetičkih podataka

Moderna praksa sve više koristi velike modele za generiranje podataka za treniranje manjih modela. Ovo je posebno korisno kad imate ograničen pristup stvarnim podatcima domene.

import anthropic
import json

klijent = anthropic.Anthropic()

def generiraj_primjere_treniranja(domena: str, broj_primjera: int = 50) -> list:
    """Generira sintetičke primjere treniranja za fino podešavanje."""

    prompt = f"""Generiraj {broj_primjera} raznolikih primjera za fino podešavanje
    modela u domeni: {domena}.

    Svaki primjer mora sadržavati:
    1. Realistično korisničko pitanje ili zahtjev
    2. Detaljan, točan i koristan odgovor stručnjaka

    Formatiraj kao JSON niz objekata s ključevima "instruction" i "output".
    Pokri različite razine složenosti i tipove zahtjeva.
    Odgovori ISKLJUČIVO valjanim JSON-om."""

    odgovor = klijent.messages.create(
        model="claude-sonnet-4-6-20250514",
        max_tokens=4096,
        messages=[{"role": "user", "content": prompt}]
    )

    primjeri = json.loads(odgovor.content[0].text)
    return primjeri

# Generiranje primjera za medicinsku domenu
primjeri = generiraj_primjere_treniranja("medicinska dijagnostika", 50)

# Spremanje u JSONL format
with open("trening_podaci.jsonl", "w", encoding="utf-8") as f:
    for primjer in primjeri:
        f.write(json.dumps(primjer, ensure_ascii=False) + "\n")

print(f"Generirano {len(primjeri)} primjera treniranja.")

Jedno upozorenje: prije korištenja vlasničkog modela za generiranje podataka za treniranje, obavezno provjerite uvjete korištenja davatelja usluge. Mnogi davatelji zabranjuju korištenje izlaza njihovih modela za treniranje konkurentskih modela. Sigurna alternativa je korištenje moćnog modela otvorenog koda poput Llama 3.3 ili Mistral Large za generiranje sintetičkih podataka.

Praktični vodič: LoRA fino podešavanje s Hugging Face

Dosta teorije — prelazimo na praktičnu implementaciju. Koristit ćemo Hugging Face ekosustav — transformers, PEFT i TRL biblioteke — koje su de facto standard za fino podešavanje modela otvorenog koda.

Postavljanje okruženja

# Instalacija potrebnih paketa
pip install transformers datasets peft accelerate trl torch bitsandbytes

# Provjera dostupnosti GPU-a
python -c "import torch; print(f'GPU: {torch.cuda.get_device_name(0)}')"

Korak 1: Učitavanje i priprema modela

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, TaskType, get_peft_model
from datasets import load_dataset
import torch

# Odabir baznog modela
model_id = "meta-llama/Llama-3.3-8B-Instruct"

# Učitavanje tokenizatora
tokenizator = AutoTokenizer.from_pretrained(model_id)
tokenizator.pad_token = tokenizator.eos_token
tokenizator.padding_side = "right"

# Učitavanje modela s automatskim mapiranjem uređaja
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    attn_implementation="flash_attention_2"  # Brža pažnja
)

print(f"Model učitan. Parametri: {model.num_parameters():,}")

Korak 2: Konfiguracija LoRA adaptora

# Definiranje LoRA konfiguracije
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                          # Rang matrica — dobar balans kvalitete i učinkovitosti
    lora_alpha=32,                 # Faktor skaliranja (2x rang)
    lora_dropout=0.05,             # Blagi dropout za regularizaciju
    bias="none",                   # Ne treniramo pristranosti
    target_modules=[               # Ciljni slojevi za LoRA
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ]
)

# Primjena LoRA na model
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# Primjer izlaza: trainable params: 13,631,488 || all params: 8,043,151,360 || trainable%: 0.17%

Pogledajte taj postotak — samo 0,17% parametara! To je ljepota LoRA pristupa.

Korak 3: Priprema skupa podataka

from datasets import Dataset
import json

# Učitavanje JSONL podataka
def ucitaj_jsonl(putanja: str) -> Dataset:
    """Učitava JSONL datoteku i priprema Dataset objekt."""
    primjeri = []
    with open(putanja, "r", encoding="utf-8") as f:
        for linija in f:
            primjeri.append(json.loads(linija))
    return Dataset.from_list(primjeri)

# Funkcija za formatiranje primjera u chat predložak
def formatiraj_primjer(primjer):
    """Pretvara instrukcijski format u chat format za Llama 3."""
    poruke = [
        {"role": "system", "content": "Ti si stručni asistent za analizu financijskih podataka."},
        {"role": "user", "content": primjer["instruction"]},
        {"role": "assistant", "content": primjer["output"]}
    ]

    tekst = tokenizator.apply_chat_template(
        poruke,
        tokenize=False,
        add_generation_prompt=False
    )
    return {"text": tekst}

# Učitavanje i formatiranje podataka
dataset = ucitaj_jsonl("trening_podaci.jsonl")
dataset = dataset.map(formatiraj_primjer)

# Podjela na trening i validacijski skup (90/10)
dataset = dataset.train_test_split(test_size=0.1, seed=42)
print(f"Trening: {len(dataset['train'])} | Validacija: {len(dataset['test'])}")

Korak 4: Pokretanje treniranja

from trl import SFTTrainer, SFTConfig

# Konfiguracija treniranja
trening_config = SFTConfig(
    output_dir="./rezultati-fino-podesavanje",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,     # Efektivna veličina serije: 4 × 4 = 16
    learning_rate=2e-4,
    weight_decay=0.01,
    warmup_ratio=0.1,                  # 10% koraka za zagrijavanje
    lr_scheduler_type="cosine",        # Kosinusni raspored učenja
    logging_steps=10,
    eval_strategy="steps",
    eval_steps=50,
    save_strategy="steps",
    save_steps=100,
    save_total_limit=3,                # Čuvaj samo 3 posljednje kontrolne točke
    bf16=True,                         # BFloat16 preciznost
    gradient_checkpointing=True,       # Štedi memoriju
    max_seq_length=2048,
    dataset_text_field="text",
    report_to="wandb",                 # Praćenje s Weights & Biases
)

# Inicijalizacija trenera
trener = SFTTrainer(
    model=model,
    args=trening_config,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=lora_config,
)

# Pokretanje treniranja
trener.train()

# Spremanje fino podešanog adaptora
trener.save_model("./lora-adaptor-financije")
print("Fino podešavanje završeno. Adaptor spremljen.")

QLoRA: Fino podešavanje na potrošačkom hardveru

Ovo je dio koji osobno smatram najzanimljivijim. Ako raspolažete samo jednim GPU-om sa 16–24 GB VRAM-a (ili čak manje), QLoRA vam omogućuje fino podešavanje modela koji bi inače bili potpuno nedostupni. Ključna razlika u odnosu na standardnu LoRA-u je kvantizacija baznog modela na 4 bita:

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, prepare_model_for_kbit_training
import torch

# QLoRA konfiguracija kvantizacije
konfiguracija_kvantizacije = BitsAndBytesConfig(
    load_in_4bit=True,                     # 4-bitna kvantizacija
    bnb_4bit_quant_type="nf4",             # NormalFloat4 tip
    bnb_4bit_compute_dtype=torch.bfloat16, # Računanje u BFloat16
    bnb_4bit_use_double_quant=True,        # Dvostruka kvantizacija
)

# Učitavanje kvantiziranog modela
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.3-8B-Instruct",
    quantization_config=konfiguracija_kvantizacije,
    device_map="auto",
    attn_implementation="flash_attention_2"
)

# Priprema modela za k-bitno treniranje
model = prepare_model_for_kbit_training(model)

# LoRA konfiguracija za QLoRA
qlora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    target_modules="all-linear",           # Primijeni na sve linearne slojeve
    task_type="CAUSAL_LM",
    modules_to_save=["lm_head", "embed_tokens"]  # Sačuvaj kritične module
)

# Memorijski otisak
upotreba_memorije = torch.cuda.max_memory_allocated() / 1024**3
print(f"Memorija GPU-a: {upotreba_memorije:.1f} GB")
# Tipični izlaz za 8B model: ~6-8 GB (umjesto 16+ GB bez kvantizacije)

S QLoRA-om, model Llama 3.3 8B zauzima oko 6–8 GB VRAM-a — što znači da ga možete fino podesiti čak i na RTX 4060 sa samo 8 GB. Za usporedbu, potpuno fino podešavanje istog modela zahtijevalo bi preko 100 GB. Razlika je, blago rečeno, dramatična.

Fino podešavanje putem OpenAI API-ja

Za timove koji preferiraju upravljanu infrastrukturu (i ne žele se zamarati s GPU-ovima), OpenAI nudi fino podešavanje putem API-ja. Ovaj pristup eliminira potrebu za upravljanjem hardverom, ali dolazi uz kompromise u kontroli i transparentnosti.

Priprema podataka za OpenAI

import json

# OpenAI koristi chat format u JSONL-u
primjeri_treniranja = [
    {
        "messages": [
            {"role": "system", "content": "Ti si stručnjak za korisničku podršku tvrtke TechCorp. Odgovaraj profesionalno, koncizno i na hrvatskom jeziku."},
            {"role": "user", "content": "Ne mogu se prijaviti u svoj račun. Stalno dobivam grešku 403."},
            {"role": "assistant", "content": "Greška 403 najčešće znači da je vaš račun privremeno zaključan. Evo koraka za rješavanje:\n\n1. Pričekajte 15 minuta i pokušajte ponovno\n2. Provjerite koristite li ispravnu e-mail adresu\n3. Kliknite na \"Zaboravljena lozinka\" za resetiranje\n\nAko problem i dalje postoji, mogu vam resetirati račun ručno. Trebat će mi vaša e-mail adresa za verifikaciju."}
        ]
    },
    {
        "messages": [
            {"role": "system", "content": "Ti si stručnjak za korisničku podršku tvrtke TechCorp. Odgovaraj profesionalno, koncizno i na hrvatskom jeziku."},
            {"role": "user", "content": "Koliko košta nadogradnja na Pro plan?"},
            {"role": "assistant", "content": "Pro plan košta 29,99 EUR mjesečno ili 299,99 EUR godišnje (ušteda od 17%). Pro plan uključuje:\n\n- Neograničen broj projekata\n- Prioritetnu podršku (odgovor unutar 2 sata)\n- Naprednu analitiku\n- API pristup\n\nMogu vam aktivirati 14-dnevnu besplatnu probnu verziju ako želite isprobati prije odluke."}
        ]
    }
]

# Spremanje u JSONL
with open("openai_trening.jsonl", "w", encoding="utf-8") as f:
    for primjer in primjeri_treniranja:
        f.write(json.dumps(primjer, ensure_ascii=False) + "\n")

Pokretanje finog podešavanja putem API-ja

from openai import OpenAI

klijent = OpenAI()

# Korak 1: Učitavanje datoteke za treniranje
datoteka = klijent.files.create(
    file=open("openai_trening.jsonl", "rb"),
    purpose="fine-tune"
)
print(f"Datoteka učitana: {datoteka.id}")

# Korak 2: Pokretanje posla finog podešavanja
posao = klijent.fine_tuning.jobs.create(
    training_file=datoteka.id,
    model="gpt-4.1-nano-2025-04-14",   # Manji model — brže i jeftinije
    hyperparameters={
        "n_epochs": 3,
        "batch_size": "auto",
        "learning_rate_multiplier": "auto"
    },
    suffix="techcorp-podrska"           # Sufiks u imenu modela
)
print(f"Posao pokrenut: {posao.id}")

# Korak 3: Praćenje napretka
import time
while True:
    status = klijent.fine_tuning.jobs.retrieve(posao.id)
    print(f"Status: {status.status}")
    if status.status in ["succeeded", "failed", "cancelled"]:
        break
    time.sleep(60)

# Korak 4: Korištenje fino podešanog modela
if status.status == "succeeded":
    fino_model = status.fine_tuned_model
    print(f"Model spreman: {fino_model}")

    odgovor = klijent.chat.completions.create(
        model=fino_model,
        messages=[
            {"role": "system", "content": "Ti si stručnjak za korisničku podršku tvrtke TechCorp."},
            {"role": "user", "content": "Kako mogu promijeniti svoju e-mail adresu?"}
        ]
    )
    print(odgovor.choices[0].message.content)

Vrijedi spomenuti da je OpenAI krajem 2025. dodao podršku za pojačano fino podešavanje (Reinforcement Fine-Tuning) za model o4-mini, koje koristi programabilne evaluatore umjesto parova primjera. Ova metoda omogućuje modelu da uči iz povratnih informacija evaluatora — posebno korisno za zadatke gdje je teško definirati točan izlaz, ali je relativno lako ocijeniti kvalitetu odgovora.

Evaluacija: Kako mjeriti uspjeh finog podešavanja

Fino podešavanje bez sustavne evaluacije je kao vožnja bez instrumentne ploče — možda stižete na odredište, ali nemate pojma koliko učinkovito. Evaluacija obuhvaća automatske metrike, ljudsku procjenu i A/B testiranje.

Automatske metrike

from datasets import load_metric
import numpy as np

def evaluiraj_model(model, tokenizator, test_dataset):
    """Evaluacija fino podešanog modela na testnom skupu."""

    rezultati = {
        "tocnost": [],
        "rouge_l": [],
        "bleu": []
    }

    rouge = load_metric("rouge")

    for primjer in test_dataset:
        ulaz = primjer["instruction"]
        ocekivani = primjer["output"]

        # Generiranje odgovora
        ulazi = tokenizator(ulaz, return_tensors="pt").to(model.device)
        izlazi = model.generate(
            **ulazi,
            max_new_tokens=512,
            temperature=0.1,
            do_sample=True
        )
        generirani = tokenizator.decode(izlazi[0], skip_special_tokens=True)

        # ROUGE-L za kvalitetu teksta
        rouge_rezultat = rouge.compute(
            predictions=[generirani],
            references=[ocekivani]
        )
        rezultati["rouge_l"].append(rouge_rezultat["rougeL"].mid.fmeasure)

    # Agregacija rezultata
    prosjek_rouge = np.mean(rezultati["rouge_l"])
    print(f"Prosječni ROUGE-L: {prosjek_rouge:.4f}")

    return rezultati

Domenski specifična evaluacija

Za produkcijske sustave, generičke metrike jednostavno nisu dovoljne. Trebate evaluacijske kriterije specifične za vašu domenu:

def domenski_evaluator(generirani_odgovor: str, kriteriji: dict) -> dict:
    """Evaluacija prema domenski specifičnim kriterijima pomoću LLM-a kao suca."""

    prompt_evaluacije = f"""Evaluiraj sljedeći odgovor korisničke podrške prema kriterijima.

ODGOVOR ZA EVALUACIJU:
{generirani_odgovor}

KRITERIJI (ocijeni svaki 1-5):
1. Točnost informacija — jesu li podatci ispravni?
2. Ton komunikacije — je li profesionalan i empatičan?
3. Potpunost — jesu li svi aspekti pitanja pokriveni?
4. Djelotvornost — sadrži li konkretne korake za rješavanje?
5. Sigurnost — izbjegava li odavanje osjetljivih informacija?

Odgovori u JSON formatu:
{{"tocnost": X, "ton": X, "potpunost": X, "djelotvornost": X, "sigurnost": X, "ukupno": X, "komentar": "..."}}"""

    # Korištenje jakog modela kao evaluatora
    klijent = anthropic.Anthropic()
    odgovor = klijent.messages.create(
        model="claude-sonnet-4-6-20250514",
        max_tokens=500,
        messages=[{"role": "user", "content": prompt_evaluacije}]
    )

    return json.loads(odgovor.content[0].text)

Praćenje degradacije performansi

Jedan od najvažnijih, a često zanemarenih aspekata evaluacije jest praćenje katastrofalnog zaboravljanja. Fino podešani model može izvrsno obavljati ciljni zadatak, ali pritom izgubiti opće sposobnosti. Ovo se događa češće nego što biste mislili. Redovito testirajte model na skupu općih zadataka kako biste osigurali da fino podešavanje nije narušilo temeljne kompetencije.

Produkcijska primjena: Od adaptora do servisa

Kad ste zadovoljni rezultatima evaluacije, vrijeme je za primjenu u produkciji. Dva su glavna pristupa za posluživanje fino podešanih modela.

Spajanje adaptora s baznim modelom

from peft import PeftModel
from transformers import AutoModelForCausalLM
import torch

# Učitavanje baznog modela u punoj preciznosti
bazni_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.3-8B-Instruct",
    torch_dtype=torch.float16,
    device_map="auto"
)

# Učitavanje LoRA adaptora
model_s_adaptorom = PeftModel.from_pretrained(
    bazni_model,
    "./lora-adaptor-financije"
)

# Spajanje adaptora u bazne težine
spojeni_model = model_s_adaptorom.merge_and_unload()

# Spremanje spojenog modela
spojeni_model.save_pretrained("./spojeni-model-financije")
tokenizator.save_pretrained("./spojeni-model-financije")
print("Model spojen i spremljen za produkcijsku primjenu.")

Posluživanje s vLLM-om

vLLM je trenutno najbrži open-source sustav za posluživanje LLM-ova. Podržava izravno učitavanje LoRA adaptora bez spajanja, što omogućuje brzo prebacivanje između različitih adaptora:

# Pokretanje vLLM servera sa spojenim modelom
python -m vllm.entrypoints.openai.api_server \
    --model ./spojeni-model-financije \
    --host 0.0.0.0 \
    --port 8000 \
    --max-model-len 4096 \
    --dtype float16 \
    --gpu-memory-utilization 0.9

# Ili izravno s LoRA adaptorom (bez spajanja)
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.3-8B-Instruct \
    --enable-lora \
    --lora-modules financije=./lora-adaptor-financije \
    --max-lora-rank 16

Praćenje u produkciji

Fino podešani model u produkciji zahtijeva kontinuirano praćenje. Performanse modela mogu degradirati s vremenom kako se mijenjaju obrasci korisničkih zahtjeva — koncept poznat kao data drift. Ključne metrike za praćenje:

  • Latencija — vrijeme odgovora pod opterećenjem
  • Kvaliteta izlaza — automatska evaluacija uzoraka pomoću LLM-a kao suca
  • Stopa pogrešaka — udio odgovora koji ne prolaze validaciju formata
  • Korisničke povratne informacije — ocjene i prijave problema
  • Drift detekcija — usporedba distribucija ulaznih zahtjeva s distribucijama iz treninga

Preporuka je postaviti automatizirane alarme koji se aktiviraju kad bilo koja metrika padne ispod definiranih pragova. I svakako implementirajte mehanizam automatskog vraćanja na prethodnu verziju modela ako kvaliteta značajno padne — bolje je imati taj sigurnosni ventil i nikad ga ne koristiti, nego ga trebati i nemati.

Sigurnosni aspekti finog podešavanja

O ovome se premalo govori, ali fino podešavanje uvodi specifične sigurnosne rizike koje morate adresirati:

  • Trovanje podataka — zlonamjerni primjeri u skupu podataka mogu uvesti neželjeno ponašanje. Implementirajte validaciju i pregled podataka prije treniranja.
  • Curenje privatnih podataka — model može memorirati i reproducirati osjetljive informacije iz skupa podataka. Koristite tehnike poput diferencijalne privatnosti i anonimizacije podataka.
  • Jailbreak ranjivosti — fino podešani modeli mogu biti ranjiviji na napade obilaženja sigurnosnih ograda. Testirajte model s poznatim napadnim promptovima prije primjene u produkciji.
  • Zaštita intelektualnog vlasništva — LoRA adaptori sadrže specifično znanje vaše domene. Zaštitite ih jednako kao i druge poslovne tajne.

Troškovi i usporedba pristupa

Razumijevanje troškova pomaže u donošenju informirane odluke, pa da razjasnimo.

Za model s 8 milijardi parametara, potpuno fino podešavanje zahtijeva 4 do 8 GPU-ova visokog kapaciteta i košta između 500 i 2.000 USD po pokretanju, ali nudi najvišu kvalitetu. LoRA fino podešavanje drastično smanjuje zahtjeve — dovoljan je jedan GPU s 24 GB VRAM-a, a troškovi padaju na 50 do 200 USD, uz zadržavanje 90 do 95 posto kvalitete.

QLoRA ide korak dalje i radi čak na GPU-u s 8 GB VRAM-a, uz troškove od 20 do 100 USD, s nešto nižom kvalitetom (80 do 90 posto). OpenAI API nudi najpristupačniji ulaz — ne trebate vlastiti GPU, a troškovi ovise o broju tokena, tipično 10 do 100 USD za manje skupove podataka.

Za većinu timova, LoRA ili QLoRA predstavljaju optimalan omjer troškova, kvalitete i fleksibilnosti. Potpuno fino podešavanje opravdano je samo kad trebate apsolutno najvišu kvalitetu i imate resurse za to. API fino podešavanje? Idealno za timove bez ML infrastrukture koji žele brzo prototipirati.

Zaključak i sljedeći koraci

Fino podešavanje velikih jezičnih modela prešlo je put od ekskluzivne mogućnosti tehnoloških divova do pristupačne tehnike koju može primijeniti svaki razvojni tim. S tehnikama poput LoRA-e i QLoRA-e, fino podešavanje modela sa 8 milijardi parametara moguće je na jednoj potrošačkoj grafičkoj kartici, uz troškove niže od 100 USD. To je bilo nezamislivo još prije par godina.

Ključni zaključci iz ovog vodiča:

  1. Počnite s jasnim ciljem — definirajte što točno želite poboljšati prije nego počnete s finim podešavanjem
  2. Kvaliteta podataka iznad svega — 1.000 izvrsnih primjera nadmašuje 10.000 osrednjih
  3. LoRA/QLoRA za većinu slučajeva — parametarski učinkovito fino podešavanje nudi optimalan balans troškova i kvalitete
  4. Sustavna evaluacija — koristite kombinaciju automatskih metrika, domenski specifičnih evaluatora i ljudske procjene
  5. Kontinuirano praćenje — model u produkciji zahtijeva stalno praćenje performansi i kvalitete

U sljedećim člancima istražit ćemo napredne teme poput pojačanog finog podešavanja (RFT), destilacije znanja iz velikih u male modele i optimizacije inferencije. Fino podešavanje je tek početak — pravo umijeće leži u izgradnji cjelovitog sustava koji se kontinuirano poboljšava na temelju stvarnih podataka iz produkcije.

O Autoru Editorial Team

Our team of expert writers and editors.