Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Automatsko vrednovanje promptova

Lekcija 16 od 16 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. Automatsko vrednovanje promptova
  2. Vrste vrednovanja
  3. Potpuni pipeline za vrednovanje
  4. Skup testova: Format
  5. Integracija u CI/CD
  6. Nadzorna ploča za vrednovanje
  7. Postavi svoje zaštitne ograde
  8. Ključne točke
  9. Provjeri svoje znanje

Lekcija ažurirana 3. studenoga 2026. na temelju OpenAI dokumentacije: temperature i top_p prihvaćeni su samo uz napor rezoniranja (reasoning effort) od none, dok modeli GPT-5.6 prema zadanim postavkama rezoniraju (medium). Pozivi koji postavljaju ove parametre stoga moraju specificirati reasoning={"effort": "none"} (Responses API) ili reasoning_effort="none" (Chat Completions). Izvori: Korištenje GPT-6 · GPT-5.6 Terra.

Automatsko vrednovanje promptova

Automatsko vrednovanje temelj je zrelog procesa inženjeringa promptova. Omogućuje ti otkrivanje regresija, usporedbu modela i validaciju promjena prije implementacije. Bez njega, svaka promjena prompta slijepa je oklada.

Vrste vrednovanja

Tri obitelji evaluatora dijele posao ovisno o prirodi očekivanog izlaza, a gotovo ćeš ih uvijek kombinirati nekoliko.

Vrednovanje točnog podudaranja (Exact Match)

Za zadatke s jednim očekivanim odgovorom, izravna usporedba je dovoljna. eval_exact_match normalizira velika i mala slova te razmake prije usporedbe: bez ove mjere opreza, „Bug“ i „bug“ računali bi se kao pogreška, šaljući te da popravljaš problem koji ne postoji.

eval_set_match rješava slučajeve gdje je odgovor skup—entiteti pronađeni u dokumentu, kategorije dodijeljene članku. Izvodi preciznost i odziv (recall), dvije brojke koje pričaju različite priče: visoka preciznost s niskim odzivom signalizira previše oprezan model koji izvlači samo ono u što je siguran; obrnuto odaje model koji halucinira kako bi popunio praznine. F1 ih zgodno sažima, ali ne zamjenjuje ih za dijagnostiku.

def eval_exact_match(prediction: str, reference: str) -> bool:
    """Točno podudaranje nakon normalizacije."""
    return prediction.strip().lower() == reference.strip().lower()

def eval_set_match(prediction: set, reference: set) -> dict:
    """Podudaranje skupova (entiteti, kategorije)."""
    tp = len(prediction & reference)
    fp = len(prediction - reference)
    fn = len(reference - prediction)

    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
    f1 = (2 * precision * recall / (precision + recall)
          if (precision + recall) > 0 else 0)

    return {"precision": precision, "recall": recall, "f1": f1}

Semantičko vrednovanje (Embedding)

Za tekstualne odgovore gdje formulacija može varirati, točno podudaranje postaje apsurdno: „Vaša narudžba bit će isporučena sutra“ i „Isporuka je zakazana za sutra“ govore istu stvar, no dobile bi nulu. Kosinusna sličnost između embeddinga mjeri semantičku bliskost umjesto podudaranja znakova, vraćajući kontinuirani rezultat.

Postavljaš prag iznad kojeg se odgovor smatra prihvatljivim. Kalibriraj ga na nekoliko desetaka parova koje si ručno klasificirao kao „ekvivalentne“ ili „različite“, zatim odaberi vrijednost koja najbolje razdvaja te dvije skupine: prag odabran osjećajem daje rezultate jednako arbitrarne kao i nepostojanje mjerenja, uz dodanu iluziju rigoroznosti.

from openai import OpenAI
import numpy as np

client = OpenAI()

def eval_semantic_similarity(prediction: str,
                              reference: str) -> float:
    """Kosinusna sličnost između embeddinga."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[prediction, reference]
    )
    emb_pred = np.array(response.data[0].embedding)
    emb_ref = np.array(response.data[1].embedding)

    similarity = float(
        np.dot(emb_pred, emb_ref) /
        (np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
    )
    return similarity

Vrednovanje pomoću LLM-a (LLM-as-Judge)

Model procjenjuje kvalitetu odgovora. Ovo je jedini izvodljiv pristup kada ne postoji referenca: nitko neće ručno pisati „točan“ odgovor podrške za dvjesto tiketa.

Ono što sudca čini upotrebljivim svodi se na nekoliko stvari. Prvo, korišteni model: biraš sposobniji model kao suca, ovdje gpt-5.6-sol, jer sudac iste razine kao onaj koji se vrednuje teži validirati vlastite mane. Drugo, zahtijevanje obrazloženja: motiviranje svake ocjene stabilizira prosudbu i omogućuje ti da uočiš evaluatora koji koristi pogrešan kriterij—obrazloženje koje raspravlja o duljini kada je kriterij bila jasnoća crvena je zastavica. Konačno, temperature na 0.1 osigurava stabilnost ocjena kroz pokretanja.

def eval_llm_judge(question: str, prediction: str,
                    criteria: list[str]) -> dict:
    """Vrednovanje od strane modela suca."""
    criteria_text = "\n".join(
        f"- {c}: ocjena od 1 do 5" for c in criteria
    )

    response = client.responses.create(
        model="gpt-5.6-sol",  # Sposobniji model kao sudac
        reasoning={"effort": "none"},  # temperature zahtijeva effort none
        instructions="Ti si stručni, nepristrani evaluator.",
        input=f"""Ocijeni ovaj odgovor prema sljedećim kriterijima:

Postavljeno pitanje: {question}

Odgovor za evaluaciju: {prediction}

Kriteriji:
{criteria_text}

Za svaki kriterij daj ocjenu od 1 do 5 s obrazloženjem.""",
        text={
            "format": {
                "type": "json_schema",
                "name": "evaluation",
                "schema": {
                    "type": "object",
                    "properties": {
                        "scores": {
                            "type": "array",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "criterion": {"type": "string"},
                                    "score": {"type": "integer"},
                                    "justification": {"type": "string"}
                                },
                                "required": ["criterion", "score",
                                              "justification"],
                                "additionalProperties": False
                            }
                        },
                        "overall_score": {"type": "number"},
                        "verdict": {"type": "string"}
                    },
                    "required": ["scores", "overall_score", "verdict"],
                    "additionalProperties": False
                },
                "strict": True
            }
        },
        temperature=0.1
    )
    return json.loads(response.output_text)

Potpuni pipeline za vrednovanje

EvalPipeline sastavlja ove gradivne blokove: učitava skup testova, pokreće prompt na svakom slučaju, primjenjuje sve pružene evaluatore i agregira rezultate. Evaluatori se prosljeđuju kao popis funkcija, sve pozvane s istim potpisom; dodavanje metrike stoga ne zahtijeva modifikaciju pipelinea, a možeš pokrenuti točno podudaranje, semantičku sličnost i suca na istom izvršenju bez plaćanja generiranja tri puta.

Metoda summary također akumulira potrošene tokene. Ova naizgled sporedna linija štiti te od česte zamke: verzija prompta koja dobije dva boda, ali utrostruči račun, nije nužno pravi izbor, i bolje je to naučiti u trenutku trade-offa nego kada stigne mjesečni račun.

import json
from dataclasses import dataclass
from pathlib import Path

@dataclass
class TestCase:
    """Testni slučaj za vrednovanje."""
    input_text: str
    expected_output: str = None
    metadata: dict = None

class EvalPipeline:
    """Automatizirani pipeline za vrednovanje."""

    def __init__(self, test_suite_path: str):
        """Učitava skup testova iz JSON datoteke."""
        data = json.loads(Path(test_suite_path).read_text())
        self.test_cases = [TestCase(**tc) for tc in data]
        self.results = []

    def run(self, prompt_config: dict,
            evaluators: list[callable]) -> dict:
        """Pokreće sve testove i vrednuje rezultate."""
        self.results = []

        for tc in self.test_cases:
            # Generiraj odgovor
            response = client.responses.create(
                model=prompt_config["model"],
                reasoning={"effort": "none"},  # temperature zahtijeva effort none
                instructions=prompt_config["system_prompt"],
                input=tc.input_text,
                temperature=prompt_config.get("temperature", 0.1)
            )

            prediction = response.output_text

            # Evaluiraj sa svakim evaluatorom
            scores = {}
            for evaluator in evaluators:
                score = evaluator(
                    question=tc.input_text,
                    prediction=prediction,
                    reference=tc.expected_output
                )
                scores[evaluator.__name__] = score

            self.results.append({
                "input": tc.input_text,
                "expected": tc.expected_output,
                "prediction": prediction,
                "scores": scores,
                "tokens": {
                    "input": response.usage.input_tokens,
                    "output": response.usage.output_tokens
                }
            })

        return self.summary()

    def summary(self) -> dict:
        """Sažima rezultate vrednovanja."""
        if not self.results:
            return {"error": "Nema rezultata"}

        # Agregiraj rezultate po evaluatoru
        all_scores = {}
        for result in self.results:
            for eval_name, score in result["scores"].items():
                if eval_name not in all_scores:
                    all_scores[eval_name] = []
                if isinstance(score, (int, float)):
                    all_scores[eval_name].append(score)
                elif isinstance(score, dict) and "f1" in score:
                    all_scores[eval_name].append(score["f1"])

        summary = {
            "total_tests": len(self.results),
            "average_scores": {
                name: sum(scores) / len(scores)
                for name, scores in all_scores.items()
                if scores
            },
            "total_token_cost": sum(
                r["tokens"]["input"] + r["tokens"]["output"]
                for r in self.results
            )
        }
        return summary

Skup testova: Format

Format skupa testova namjerno je minimalan: ulaz, očekivani izlaz i metapodaci slobodnog oblika. Ovi metapodaci korisniji su nego što se čini—označavanjem svakog slučaja po kategoriji, razlažeš rezultate i otkrivaš da tvoj klasifikator ne faila nasumično, već na specifičnoj obitelji zahtjeva, što globalni prosjek od 88% ne otkriva. Tri primjera u nastavku također pokazuju što dobar skup treba sadržavati: jasne slučajeve, poput rušenja pri pokretanju, ali i slučajeve koji graniče s drugom kategorijom—pitanje o nedostajućoj funkciji vrlo liči na prijavu buga, a upravo se na toj granici odlučuje o kvaliteti klasifikatora.

[
    {
        "input_text": "Moj paket nije stigao",
        "expected_output": "prigovor",
        "metadata": {"category": "isporuka"}
    },
    {
        "input_text": "Kako da uključim tamni način rada?",
        "expected_output": "pitanje",
        "metadata": {"category": "funkcija"}
    },
    {
        "input_text": "Aplikacija se ruši pri pokretanju na iOS 18",
        "expected_output": "bug",
        "metadata": {"category": "tehničko"}
    }
]

Integracija u CI/CD

Pokreni vrednovanje pri svakoj promjeni prompta. Funkcija ci_eval_check pretvara mjerenje u zaštitnu ogradu: pokreće pipeline, uspoređuje prosječnu ocjenu s pragom i vraća boolean koji tvoj lanac integracije tumači kao uspjeh ili neuspjeh builda. Promjena koja spusti preciznost ispod 85% više ne stiže u produkciju, baš kao što pokrenuti unit test blokira merge.

Postavi prag na temelju rezultata koje već postiže trenutna verzija, a ne iz ideala. Postaviš li ga previsoko, osuđuješ tim na zaobilaženje provjere privremenim onemogućavanjima koja postaju trajna; postaviš li prenisko, ne provjeravaš ništa dok prikazuješ zelenu značku. Konačno, imaj na umu da skup testova mora ostati reprezentativan za stvarni promet: prag postignut na dvadeset slučajeva napisanih prije dvije godine ne dokazuje ništa o današnjim zahtjevima.

def ci_eval_check(prompt_config: dict,
                   test_suite: str,
                   min_score: float = 0.85) -> bool:
    """CI/CD prolaz: provjerava zadovoljava li prompt minimalnu ocjenu."""
    pipeline = EvalPipeline(test_suite)

    def accuracy(question, prediction, reference):
        return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0

    results = pipeline.run(prompt_config, [accuracy])
    avg_score = results["average_scores"].get("accuracy", 0)

    print(f"Prosječna ocjena: {avg_score:.2%}")
    print(f"Minimalni prag: {min_score:.2%}")

    if avg_score < min_score:
        print("NEUSPJEH: ocjena ispod praga")
        return False

    print("USPJEH: prompt validiran")
    return True

Nadzorna ploča za vrednovanje

Prati evoluciju rezultata kroz vrijeme. Jedna ocjena ne govori ništa; niz priča povijest tvog prompta i odgovara na pitanje koje se uvijek pojavi na sastancima: napredujemo li? Funkcija u nastavku proizvodi Markdown tablicu koja jedna do druge stavlja, za svaku verziju, prosječnu ocjenu, potrošene tokene i procijenjeni trošak. Format nije slučajan: lijepi se izravno u pull request, čineći usporedbu čitljivom ljudima koji nikada neće otvoriti tvoj kod.

def comparison_report(results: dict[str, dict]) -> str:
    """Generira komparativno izvješće između verzija promptova."""
    report = "# Izvješće o komparativnom vrednovanju\n\n"
    report += "| Verzija | Prosječna ocjena | Prosječni tokeni | Trošak |\n"
    report += "|---------|---------------|----------------|------|\n"

    for version, data in results.items():
        score = data.get("average_scores", {})
        score_val = list(score.values())[0] if score else 0
        tokens = data.get("total_token_cost", 0)
        report += (f"| {version} | {score_val:.2%} | "
                   f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")

    return report

Postavi svoje zaštitne ograde

Izgradi skup od dvadeset testnih slučajeva za stvarni prompt, stavljajući šaku rubnih slučajeva umjesto dvadeset udobnih primjera: skup koji prolazi sa 100% iz prvog pokušaja ne uči te ničemu. Implementiraj tri vrste evaluatora i pokreni ih zajedno na dvije verzije svog prompta. Točno podudaranje daje čistu brojku, semantička sličnost hvata legitimna preformuliranja, a sudac osvjetljava slučajeve gdje se prva dva ne slažu—ova neslaganja najbogatija su lekcijama o tome što zapravo očekuješ od modela.

Usporedi, identificiraj pobjedničku verziju, zatim postavi CI skriptu koja blokira implementaciju ako ocjena padne. Znati ćeš da sustav radi onog dana kada odbije promjenu za koju si mislio da je očita.

Ključne točke

  • Automatsko vrednovanje ključno je za iteracije s povjerenjem
  • Kombiniraj vrednovanje točnog podudaranja, semantičko i LLM-as-judge prema potrebi
  • Održavaj skup testova koji evoluira s tvojom aplikacijom
  • Integriraj vrednovanje u svoj CI/CD s minimalnim pragom
  • Koristi sposobniji model kao suca za vrednovanje jeftinijeg modela
  • Dokumentiraj rezultate svake verzije kako bi pratio evoluciju

Provjeri svoje znanje

Napredne tehnike i industrializacija: završna provjera.

1. Što sadrži učinkovit sistemski prompt?

Odgovor: Ulogu, opseg, pravila ponašanja, format izlaza i rukovanje rubnim slučajevima—napisano kao specifikacija, testirano kao kod.

2. Kada trebaš koristiti samokonzistentnost (self-consistency)?

Odgovor: Na problemima rezoniranja s provjerljivim odgovorima: generiraj više neovisnih rezoniranja i zadrži većinski odgovor—varijanca postaje saveznik.

3. Što jamči JSON način rada s provedbom sheme?

Odgovor: Izlaz strogo u skladu sa shemom (tipovi, obavezna polja, enumi)—validiran na strani API-ja i ponovno validiran u kodu (JSON Schema, Zod) za lanac bez iznenađenja.

4. Što je utemeljenje (grounding)?

Odgovor: Sidrenje odgovora u pruženim činjenicama (dokumenti, dohvaćeni podaci) umjesto u memoriji modela—sa zahtjevom za citiranje ili suzdržavanje od vanjskih izvora.

5. Koja je svrha kataloga promptova s verzioniranjem?

Odgovor: Da se promptovi tretiraju kao artefakti: verzije, A/B testovi, automatska vrednovanja pri svakoj promjeni—znaš što se vrti u produkciji i zašto.

Završna petlja tečaja—verzioniraj, testiraj, automatski vrednuj—pretvara zanatski inženjering promptova u timsku praksu.