Kalibracja modeli-sędziów względem ludzi
Zbierz zbiór danych referencyjnych zawierający oceny ludzkich preferencji, zmierz zgodność ocen z ocenami ludzi za pomocą współczynnika kappa Cohena i dostrój prompt sędziego, aby ograniczyć systematyczne obciążenia.
Kalibracja modeli-sędziów względem ludzi to bezpłatna lekcja AI Engineering Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Engineering Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.
Dlaczego kalibracja jest niezbędna
Nieskalibrowany oceniający LLM może systematycznie oceniać odpowiedzi wyżej lub niżej niż ludzie, preferować określony styl pisania albo zawodzić w przypadkach brzegowych, których nie przewidziano w kryteriach oceny. Korzystając z takiego oceniającego przy podejmowaniu decyzji o wdrożeniu, ufają Państwo stronniczemu narzędziu. Kalibracja weryfikuje oceniającego względem ludzkich ocen referencyjnych i określa, w jakim stopniu można ufać jego wynikom przed wykorzystaniem ich w środowisku produkcyjnym.
Tworzenie zbioru danych do kalibracji
Utwórz zbiór kalibracyjny zawierający 100–500 przykładowych odpowiedzi ocenionych przez ludzi. Zadbaj o różnorodność: uwzględnij odpowiedzi wysokiej jakości (ocena 5), średniej jakości (ocena 3) oraz wyraźnie złe (ocena 1). Niech 3–5 niezależnych oceniających oceni każdy przykład, aby zmierzyć zgodność między oceniającymi i obliczyć zgodną ocenę referencyjną, uśredniając wyniki lub wybierając dominantę.
# Calibration dataset structure:
# [
# {
# 'question': 'What causes inflation?',
# 'response': '...',
# 'human_scores': [4, 4, 3, 5, 4], # 5 raters
# 'human_consensus': 4, # mean or mode
# 'rater_ids': ['r1', 'r2', 'r3', 'r4', 'r5']
# },
# ...
# ]
# Typical calibration set composition:
# 30% excellent responses (score 4-5)
# 40% adequate responses (score 2-4)
# 30% poor responses (score 1-2)
# Include adversarial / edge casesPomiar zgodności między oceniającymi
Zanim uznasz ludzkie oceny za wartości referencyjne, sprawdź, czy oceniający są ze sobą zgodni. Kappa Cohena mierzy zgodność między dwiema osobami oceniającymi wykraczającą poza zgodność losową: wynik powyżej 0,6 jest akceptowalny, a powyżej 0,8 — doskonały. W przypadku skal pięciopunktowych oblicz ważoną kappę (wagi liniowe). Niska zgodność między oceniającymi oznacza, że zadanie zdefiniowano niejednoznacznie — ulepsz wytyczne dla oceniających, zanim użyjesz wyników do kalibracji oceniającego.
from sklearn.metrics import cohen_kappa_score
import numpy as np
def measure_inter_rater_agreement(rater1_scores: list, rater2_scores: list) -> dict:
kappa = cohen_kappa_score(rater1_scores, rater2_scores, weights='linear')
exact_agreement = sum(a == b for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
adjacent_agreement = sum(abs(a - b) <= 1 for a, b in zip(rater1_scores, rater2_scores)) / len(rater1_scores)
return {
'weighted_kappa': round(kappa, 3),
'exact_agreement': round(exact_agreement, 3),
'adjacent_agreement': round(adjacent_agreement, 3),
'acceptable': kappa >= 0.6
}Uruchamianie oceniającego na danych kalibracyjnych
Uruchom oceniającego LLM dla każdego przykładu ze zbioru kalibracyjnego, używając tego samego promptu, którego planujesz używać w środowisku produkcyjnym. Zbierz wynik oceniającego dla każdego przykładu wraz ze zgodną oceną ludzką. Zachowaj zgodność obu list, aby można było porównywać ich elementy jeden do jednego. To porównanie ujawnia systematyczne uprzedzenia i różnice w zakresach wyników.
async def run_judge_on_calibration(calibration_set: list) -> list:
pairs = []
for item in calibration_set:
judge_result = await async_judge(item['question'], item['response'])
pairs.append({
'question': item['question'],
'human': item['human_consensus'],
'judge': judge_result.correctness,
'judge_rationale': judge_result.rationale
})
return pairsObliczanie korelacji między oceniającym a ludźmi
Oblicz korelację Pearsona między wynikami oceniającego a zgodnymi ocenami ludzkimi. Mierzy ona zgodność liniową: korelacja równa 1,0 oznacza, że oceniający doskonale odzwierciedla rankingi ludzkie. Oblicz również średni błąd bezwzględny (MAE), aby określić przeciętną różnicę wyników. Korelacja powyżej 0,7 i MAE poniżej 0,8 punktu w skali pięciopunktowej zazwyczaj wskazują, że oceniający jest wystarczająco wiarygodny do użycia w środowisku produkcyjnym.
from scipy.stats import pearsonr, spearmanr
import numpy as np
def calibration_metrics(pairs: list) -> dict:
humans = [p['human'] for p in pairs]
judges = [p['judge'] for p in pairs]
pearson_r, p_val = pearsonr(humans, judges)
spearman_r, _ = spearmanr(humans, judges)
mae = np.mean([abs(h - j) for h, j in zip(humans, judges)])
return {
'pearson_r': round(pearson_r, 3),
'spearman_r': round(spearman_r, 3),
'p_value': round(p_val, 5),
'mae': round(mae, 3),
'reliable': pearson_r >= 0.7 and mae <= 0.8
}Wykrywanie systematycznych uprzedzeń
Oprócz korelacji poszukaj systematycznych uprzedzeń: czy oceniający konsekwentnie zawyża lub zaniża wyniki? Sporządź wykres wyników oceniającego względem wyników ludzkich i sprawdź, czy linia regresji nie przechodzi przez początek układu współrzędnych. Jeśli oceniający przyznaje średnio 4 tam, gdzie ludzie przyznają 3, występuje u niego uprzedzenie zawyżające wyniki. Skoryguj je, dostosowując kryteria oceny lub stosując liniową transformację kalibracyjną do surowych wyników.
import numpy as np
from scipy import stats
def detect_score_bias(pairs: list) -> dict:
humans = np.array([p['human'] for p in pairs])
judges = np.array([p['judge'] for p in pairs])
slope, intercept, r, p, se = stats.linregress(judges, humans)
bias = np.mean(judges - humans) # positive = judge over-scores
return {
'mean_bias': round(bias, 3), # > 0 means judge inflates
'calibration_slope': round(slope, 3),
'calibration_intercept': round(intercept, 3),
# Corrected score = slope * judge_score + intercept
'correction_formula': f'human_score ≈ {slope:.2f} * judge + {intercept:.2f}'
}Stosowanie korekty kalibracyjnej
Po uzyskaniu regresji kalibracyjnej (nachylenia i wyrazu wolnego) zastosuj ją, aby przekształcić surowe wyniki oceniającego w wyniki skalibrowane, lepiej odpowiadające ludzkim ocenom. Ta liniowa korekta jest prosta i skuteczna. Ogranicz skorygowany wynik do prawidłowego zakresu (1–5), aby zapobiec wartościom spoza zakresu wynikającym z regresji. Przechowuj zarówno wyniki surowe, jak i skorygowane, aby umożliwić porównania retrospektywne w miarę powiększania się danych kalibracyjnych.
def calibrate_score(raw_judge_score: float, slope: float, intercept: float,
min_score: int = 1, max_score: int = 5) -> float:
corrected = slope * raw_judge_score + intercept
return max(min_score, min(max_score, round(corrected, 1)))
# Example: if judge inflates by 0.5 points on average
# slope=0.85, intercept=0.3
# raw_score=4 -> corrected = 0.85*4 + 0.3 = 3.7Wykrywanie systematycznych wzorców błędów
Pogrupuj błędy kalibracji według typu pytania, długości odpowiedzi i obszaru tematycznego, aby znaleźć powtarzalne niepowodzenia. Oceniający może być niewiarygodny w przypadku technicznych pytań dotyczących programowania, a jednocześnie trafny w przypadku pytań faktograficznych. Może zawyżać oceny bardzo długich odpowiedzi, a zaniżać oceny krótkich i zwięzłych. Wzorce te pomagają ukierunkować ulepszenia kryteriów oceny lub tworzyć prompty oceniające specyficzne dla tematów, w których kalibracja jest najsłabsza.
from collections import defaultdict
def error_by_category(pairs: list) -> dict:
by_cat = defaultdict(list)
for p in pairs:
error = abs(p['judge'] - p['human'])
by_cat[p.get('category', 'unknown')].append(error)
return {
cat: {
'mean_error': round(sum(errs)/len(errs), 2),
'max_error': max(errs),
'n': len(errs)
}
for cat, errs in by_cat.items()
}Ponowna kalibracja wraz ze wzrostem ilości danych
Kalibracja nie jest jednorazowym zadaniem. W miarę gromadzenia większej liczby ocen ludzkich i zmian zachowania oceniającego wynikających z aktualizacji modelu ponawiaj kalibrację co kwartał. Śledź w czasie metryki kalibracji — jeśli korelacja Pearsona spadnie poniżej 0,7, sprawdź, czy aktualizacja modelu nie zmieniła rozkładu wyników oceniającego. Zautomatyzuj proces kalibracji, aby jego ponowne uruchomienie sprowadzało się do jednej komendy generującej zaktualizowany współczynnik korekty.
def run_calibration_pipeline(calibration_data: list) -> dict:
# 1. Measure human inter-rater agreement
ira = measure_inter_rater_agreement(
[d['rater_1'] for d in calibration_data],
[d['rater_2'] for d in calibration_data]
)
# 2. Run judge on all items
pairs = run_judge_on_calibration(calibration_data)
# 3. Compute correlation metrics
metrics = calibration_metrics(pairs)
# 4. Detect bias
bias = detect_score_bias(pairs)
return {'ira': ira, 'metrics': metrics, 'bias': bias}Dokumentowanie konfiguracji oceniającego
Udokumentuj model oceniający, wersję promptu, rozmiar i datę utworzenia zbioru kalibracyjnego, metryki kalibracji oraz wszelkie współczynniki korekty w pliku konfiguracyjnym oceniającego przechowywanym w systemie kontroli wersji. Tworzy to ścieżkę audytu, dzięki której przyszli członkowie zespołu rozumieją, skąd biorą się wyniki, a także mogą wykryć, czy zmiany metryk wynikają z rekonfiguracji oceniającego, czy z rzeczywistych zmian jakości.
# judge_config.yaml
# judge_model: gpt-4o-2025-01-01
# judge_prompt_version: v3.2
# calibration_date: 2026-05-15
# calibration_set_size: 312
# calibration_metrics:
# pearson_r: 0.81
# spearman_r: 0.79
# mae: 0.54
# bias_correction:
# slope: 0.88
# intercept: 0.45
# next_recalibration: 2026-08-15Prompty oceniające poszczególne wymiary
Pojedynczy prompt oceniający jednocześnie wiele wymiarów często prowadzi do skorelowanych wyników — oceniający przyznaje wysoką poprawność, ponieważ wcześniej przyznał wysoką przejrzystość, i kieruje się pierwszym wrażeniem. Prompty specyficzne dla wymiarów oceniają każde kryterium niezależnie, w osobnym wywołaniu API. Jest to droższe, ale zapewnia bardziej wiarygodne wyniki, które rzeczywiście stanowią niezależne pomiary. Używaj osobnych promptów dla wymiarów, w przypadku których oczekujesz niezależnych zmian wyników.
async def multi_dimension_judge(question: str, answer: str) -> dict:
# Run each dimension as a separate judge call
correctness, helpfulness, clarity = await asyncio.gather(
judge_single_dimension(question, answer, 'correctness'),
judge_single_dimension(question, answer, 'helpfulness'),
judge_single_dimension(question, answer, 'clarity')
)
return {
'correctness': correctness,
'helpfulness': helpfulness,
'clarity': clarity,
'composite': 0.5 * correctness + 0.3 * helpfulness + 0.2 * clarity
}Szybkie sprawdzenie
Sprawdź swoją wiedzę na temat kalibrowania modeli oceniających LLM względem ocen ludzkich.
Podsumowanie lekcji
W tej lekcji poznali Państwo: zbiory kalibracyjne ze zgodnymi ocenami ludzkimi dostarczają wartości referencyjnych do pomiaru wiarygodności oceniającego, korelacja Pearsona i MAE określają, jak dobrze oceniający odzwierciedla ludzkie oceny, a liniowa korekta uprzedzeń kompensuje systematyczne zawyżanie lub zaniżanie wyników. W następnym kroku zbudujemy ciągły proces oceny zintegrowany z CI/CD.
Często zadawane pytania
Czy lekcja „Kalibracja modeli-sędziów względem ludzi” jest bezpłatna?
Tak — pełny tekst „Kalibracja modeli-sędziów względem ludzi” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Engineering Academy, przejdź na CoddyKit PRO. Kurs AI Engineering Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Kalibracja modeli-sędziów względem ludzi”?
Zbierz zbiór danych referencyjnych zawierający oceny ludzkich preferencji, zmierz zgodność ocen z ocenami ludzi za pomocą współczynnika kappa Cohena i dostrój prompt sędziego, aby ograniczyć systemat… Ćwiczysz AI Engineering Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć AI Engineering Academy?
Nie wymagamy żadnego doświadczenia. AI Engineering Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Kalibracja modeli-sędziów względem ludzi”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji AI Engineering Academy?
Tak. Każda lekcja AI Engineering Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Wzorzec LLM-as-Judge
- Ewaluacja punktowa i porównawcza
- Kalibracja modeli-sędziów względem ludzi
- Tworzenie ciągłego potoku ewaluacji