Przejdź do głównej treści
Polski— Wybierz język
Menu

Metryki i punkty odniesienia

Lekcja 17 z 20 Zaktualizowano 3 listopada 2026 Zaawansowany
Na tej stronie
  1. Pomiar jakości za pomocą metryk
  2. Porównywanie znaczenia, a nie słów
  3. Weryfikacja, czy model nie halucynuje
  4. Tworzenie powtarzalnego benchmarku
  5. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 r. na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (API Responses) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Pomiar jakości za pomocą metryk

Poza ocenami typu LLM-as-Judge istnieją metryki ilościowe służące do ewaluacji różnych aspektów wyjść modeli językowych (LLM). Ich wartość nie polega na większej dokładności – dobrze skonstruowany sędzia LLM dostrzega rzeczy, których żadna formuła nigdy nie wychwyci – lecz na stabilności i niskim koszcie. Podobieństwo kosinusowe zwraca dokładnie tę samą liczbę przy każdym uruchomieniu, kosztuje niemal nic i dlatego może być stosowane do tysięcy przypadków przy każdym commicie. Sędzią LLM posługujesz się wtedy, gdy potrzebujesz oceny wymiarów, które tego rzeczywiście wymagają.

Przejrzymy kluczowe metryki, zanim złożymy je w powtarzalne punkty odniesienia (benchmarki).

Porównywanie znaczenia, a nie słów

Porównywanie dwóch tekstów znak po znaku staje się bezużyteczne, gdy tylko frazowanie jest dowolne. Podobieństwo semantyczne omija ten problem: każdy tekst jest konwertowany na wektor przez model osadzania (embedding), a my mierzymy kąt między tymi dwoma wektorami. Dwa zdania mówiące to samo innymi słowami wskazują ten sam kierunek.

import openai
import numpy as np

client = openai.OpenAI()

def cosine_similarity(vec_a: list[float], vec_b: list[float]) -> float:
    """Calculates the cosine similarity between two vectors."""
    a = np.array(vec_a)
    b = np.array(vec_b)
    return float(np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b)))

def semantic_similarity(text_a: str, text_b: str) -> float:
    """Measures the semantic similarity between two texts."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[text_a, text_b],
    )

    vec_a = response.data[0].embedding
    vec_b = response.data[1].embedding

    return cosine_similarity(vec_a, vec_b)

# Example
score = semantic_similarity(
    "The cat is on the rug.",
    "A feline is resting on the carpet.",
)
print(f"Similarity: {score:.3f}")  # ~0.85+

Przykład jest pouczający: dwa zdania nie mające ani jednego wspólnego słowa osiągają wynik powyżej 0,85. To siła tej metody, ale i jej pułapka. Podobieństwo semantyczne ignoruje przeczenia i niuanse stopnia – „płatność została zaakceptowana“ i „płatność została odrzucona“ wyglądają bardzo podobnie w przestrzeni wektorowej. Nigdy więc nie używaj tej metryki w izolacji do walidacji odpowiedzi, gdzie liczy się dokładność faktograficzna.

Gdy pytanie brzmi: „czy odpowiedź rzeczywiście dotyczy postawionego pytania“, żadna formuła nie zastąpi osądu. Poniższy wynik relewancji rozbija ten osąd na trzy odrębne pytania: Czy odpowiedź jest bezpośrednia? Czy pozostaje w temacie? Czy jest kompletna? Taki rozkład jest lepszy niż wynik globalny, ponieważ wskazuje kierunek korekty promptu – model gadatliwy i model niekompletny wymagają przeciwnych działań naprawczych.

def relevance_score(
    question: str,
    answer: str,
    context: str | None = None,
) -> dict:
    """Evaluates whether the answer is relevant to the question."""
    prompt = (
        "Evaluate the relevance of this answer.\n\n"
        f"Question: {question}\n"
    )
    if context:
        prompt += f"Context provided: {context[:1000]}\n"
    prompt += (
        f"Answer: {answer}\n\n"
        "Criteria:\n"
        "1. Does the answer directly address the question? (0-5)\n"
        "2. Does the answer contain unrequested information? (0-5, 5=none)\n"
        "3. Is the answer complete? (0-5)\n\n"
        "Respond in JSON with keys: direct, focus, completeness."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0,
    )

    import json
    try:
        scores = json.loads(response.output_text)
        average = sum(scores.values()) / (len(scores) * 5)
        return {"score": average, "details": scores}
    except (json.JSONDecodeError, TypeError):
        return {"score": 0, "error": "Parsing failed"}

Zwróć uwagę na odwrócone sformułowanie drugiego kryterium, gdzie 5 oznacza „brak nieżądzanych informacji“. Pozwala to sumować trzy wyniki w tym samym kierunku, ale jest to intuicyjnie mylące przy czytaniu: gdy dodajesz własne kryteria, zachowaj tę konwencję, inaczej otrzymasz średnie, które nagradzają wadę, którą zamierzałeś ukarać.

Weryfikacja, czy model nie halucynuje

W aplikacji typu Q&A opartej na dokumentach decydującą metryką nie jest jakość pisania, lecz wierność źródłu. Zasada kontroli jest prosta: przedstaw sędziowi oryginalny kontekst i wygenerowaną odpowiedź, a następnie poproś o sklasyfikowanie każdego stwierdzenia jako popartego przez kontekst, nieobecnego w kontekście lub sprzecznego z nim. Rozróżnienie między tymi dwoma ostatnimi kategoriami ma znaczenie, ponieważ stwierdzenie jedynie nieobecne może być trafną wiedzą ogólną, podczas gdy stwierdzenie sprzeczne ze źródłem jest zawsze błędem.

def detect_hallucinations(
    context: str,
    answer: str,
) -> dict:
    """Detects statements not supported by the context."""
    prompt = (
        "Analyze this answer and identify any statement "
        "that is NOT supported by the provided context.\n\n"
        f"Context: {context[:3000]}\n\n"
        f"Answer: {answer}\n\n"
        "For each statement in the answer, indicate:\n"
        "- supported: the statement is in the context\n"
        "- unsupported: the statement is not in the context\n"
        "- invented: the statement contradicts the context\n\n"
        "Respond in JSON with the key statements (list) and "
        "fidelity_score (0 to 1)."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=prompt,
        temperature=0.0,
    )

    import json
    try:
        return json.loads(response.output_text)
    except json.JSONDecodeError:
        return {"fidelity_score": 0, "error": "Parsing failed"}

Skrócenie kontekstu do 3000 znaków to limit, którego musisz być świadomy: jeśli źródło przekracza ten rozmiar, całkowicie trafne stwierdzenia zostaną policzone jako niepoparte wyłącznie dlatego, że fragment je uzasadniający został ucięty. W przypadku długich dokumentów podziel tekst i przeprowadź ewaluację sekcjami, zamiast godzić się na systematyczne fałszywe wyniki pozytywne.

Tworzenie powtarzalnego benchmarku

Benchmark to nie tylko kolejna metryka: to konfiguracja, która zamraża zbiór danych i protokół, tak aby dwa uruchomienia były ze sobą porównywalne. Poniższa klasa mierzy relewancję, wierność (gdy dostępny jest kontekst), opóźnienie (latencję) i koszt, a następnie przechowuje każdy wynik z datą i etykietą wersji promptu.

from dataclasses import dataclass, field
import time

@dataclass
class BenchmarkResult:
    model: str
    prompt_version: str
    scores: dict
    avg_latency: float
    total_cost: float
    date: str = field(default_factory=lambda: time.strftime("%Y-%m-%d"))

class Benchmark:
    """Reusable benchmark for comparing models and prompts."""

    def __init__(self, name: str, dataset: list[dict]):
        self.name = name
        self.dataset = dataset
        self.results: list[BenchmarkResult] = []

    def run(
        self,
        model: str,
        system_prompt: str,
        prompt_version: str,
    ) -> BenchmarkResult:
        """Runs the benchmark with a given model and prompt."""
        relevance_scores = []
        hallucination_scores = []
        latencies = []
        cost = 0

        for case in self.dataset:
            start = time.perf_counter()
            response = client.responses.create(
                model=model,
                instructions=system_prompt,
                input=case["input"],
            )
            latency = time.perf_counter() - start
            latencies.append(latency)

            # Evaluate
            relevance = relevance_score(
                case["input"], response.output_text
            )
            relevance_scores.append(relevance["score"])

            if case.get("context"):
                halluc = detect_hallucinations(
                    case["context"], response.output_text
                )
                hallucination_scores.append(
                    halluc.get("fidelity_score", 0)
                )

        result = BenchmarkResult(
            model=model,
            prompt_version=prompt_version,
            scores={
                "relevance": sum(relevance_scores) / len(relevance_scores),
                "fidelity": (
                    sum(hallucination_scores) / len(hallucination_scores)
                    if hallucination_scores else None
                ),
            },
            avg_latency=sum(latencies) / len(latencies),
            total_cost=cost,
        )

        self.results.append(result)
        return result

    def compare(self) -> str:
        """Compares all benchmark results."""
        lines = [f"Benchmark: {self.name}\n"]
        for r in self.results:
            lines.append(
                f"  {r.model} (prompt {r.prompt_version}) | "
                f"Relevance: {r.scores['relevance']:.2f} | "
                f"Latency: {r.avg_latency:.2f}s"
            )
        return "\n".join(lines)

Wyjście metody compare celowo umieszcza relewancję i latencję w tej samej linii, ponieważ tak właśnie podejmuje się decyzje. Model, który zyskuje dwie setne punktu w relewancji, podwajając czas odpowiedzi, nie jest lepszym wyborem dla aplikacji interaktywnej; może nim być dla przetwarzania nocnego. Tabela nie decyduje za ciebie; stawia kompromis bezpośrednio przed twoimi oczami.

Na koniec, total_cost w tej implementacji pozostaje równe zero. Uzupełnij je na podstawie pól usage zwracanych przez API: porównanie modeli pomijające koszt pomija kryterium, które rozstrzygnie dyskusję z twoim zespołem finansowym.

Kluczowe wnioski

  • Podobieństwo semantyczne mierzy znaczenie, ale pozostaje ślepe na przeczenia
  • Rozbijaj relewancję na odrębne kryteria zamiast stosować wynik globalny
  • Wykrywaj halucynacje, konfrontując odpowiedź z kontekstem źródłowym
  • Twórz powtarzalne benchmarki mierzące jednocześnie jakość, latencję i koszt
  • Łącz automatyczne metryki z podejściem LLM-as-Judge, aby uzyskać kompletną ewaluację