Logit Observability: Reading the Model's Mind with logprobs — Production Diagnostics

Ders Haritası#

1. Logit, log-prob, probability üçlüsü
2. logprobs API: OpenAI vs Anthropic vs open-source
3. Token-level confidence scoring
4. Sequence-level likelihood
5. MCQ scoring: classification için logprobs
6. Hallucination detection logprobs ile
7. Token-level entropy ve "şüphe noktaları"
8. Anomaly detection: garip pattern'leri yakalama
9. Prompt diagnostics: hangi token bilgi vermiyor
10. Semantic confidence: birden çok generation'dan
11. Production monitoring: real-time dashboards
12. Limitler: logprobs ne söylemiyor

1. Logit, Log-Prob, Probability Üçlüsü#

Dönüşümler#

logit → probability: softmax(z)
probability → log_prob: log(p)
log_prob → probability: exp(log_p)
log_prob → logit: log_p + log(Z) where Z = sum(exp(z))   # ama Z genelde bilinmiyor

Niye log-prob?#

1. Numerical stability: log(0.001) = -6.9, basit; 0.001 underflow riski
2. Sum yerine product: P(x_1, x_2) = P(x_1) × P(x_2) → log: log(P_1) + log(P_2)
3. Loss = NLL = -log P — model eğitiminin doğal dili

Pratik#

• logprob = -0.05
  →
  P ≈ 0.95
  (çok confident)
• logprob = -2.0
  →
  P ≈ 0.135
  (hayli kararsız)
• logprob = -10
  →
  P ≈ 0.00005
  (model bunu seçmez)

2. logprobs API'leri — Karşılaştırma#

OpenAI#

resp = client.chat.completions.create(
    model="gpt-5-mini",
    messages=[...],
    logprobs=True,
    top_logprobs=5,         # her token için top-5 alternatif
)
# resp.choices[0].logprobs.content

• top_logprobs
  max 20
• Her token için: token + logprob + bytes + top_logprobs
• Streaming'de chunk-by-chunk

Anthropic#

• Native
  logprobs
  yok
• Ama structured output ile workaround: schema'ya score field ekle, modelden self-evaluation iste
• Cohere, Mistral API'sinde de logprobs gibi feature var

Open-source (Llama, Qwen)#

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("...")
tok = AutoTokenizer.from_pretrained("...")

inputs = tok("prompt", return_tensors="pt")
with torch.no_grad():
    out = model(**inputs)
    logits = out.logits        # (B, T, V)
    logprobs = torch.log_softmax(logits, dim=-1)

3. Token-Level Confidence Scoring#

Basit metric: log-prob#

confidence(token) = exp(logprob)   # [0, 1]

Daha bilgilendirici: top-k logprobs gap#

margin = top_1_logprob - top_2_logprob

• margin > 5 (probability ratio 150x+): çok emin
• margin 1-3 (3x-20x ratio): orta
• margin < 0.5 (1.5x ratio): kararsız

Entropy metric#

def token_entropy(top_logprobs):
    probs = [math.exp(lp) for lp in top_logprobs]
    # Normalize (top-k yaklaşımı)
    total = sum(probs)
    probs = [p/total for p in probs]
    return -sum(p * math.log(p + 1e-10) for p in probs)

• entropy ~0: çok emin
• entropy ~1 bit: 2 seçenek arası kararsızlık
• entropy >2 bit: çok kararsız

4. Sequence-Level Likelihood#

log P(sequence) = Σ_t log P(x_t | x_<t)

sequence_logprob = sum(t.logprob for t in content)
avg_logprob = sequence_logprob / len(content)
perplexity = math.exp(-avg_logprob)

Yorumlar#

• avg_logprob > -1: çok confident response (PPL < 2.7)
• avg_logprob -1 to -2: normal (PPL 2.7-7.4)
• avg_logprob < -3: model çok kararsız, şüphe et (PPL > 20)

Length-normalized#

normalized_logprob = sequence_logprob / len(content) ** alpha   # alpha=0.7-1.0

5. MCQ Scoring — Classification için logprobs#

Naif yaklaşım: generation + parse#

Soru: "Hangisi bir dağdır? A) Everest B) Akdeniz C) Sahra"
LLM: "A) Everest"
Parse: "A"

Logprobs yaklaşımı#

# Cevap için 4 candidate token'ın logprob'unu al
candidates = [" A", " B", " C", " D"]
prompt = "Hangisi bir dağdır?\nA) Everest\nB) Akdeniz\nC) Sahra\n\nCevap:"

resp = client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": prompt}],
    logprobs=True,
    top_logprobs=20,
    max_tokens=1,
)

# Top logprobs içinden candidate'leri bul
first_token = resp.choices[0].logprobs.content[0]
scores = {}
for top in first_token.top_logprobs:
    if top.token in candidates:
        scores[top.token] = top.logprob

# En yüksek logprob
best = max(scores, key=scores.get)
print(f"Cevap: {best.strip()}")

Avantajlar#

1. Robust parsing: hiç parse yok
2. Confidence score: olasılık olarak
3. Calibration: probabilities for downstream decisions
4. Cheap: max_tokens=1, çok az output token

Benchmark improvements#

6. Hallucination Detection — logprobs ile#

Heuristic 1: average logprob threshold#

avg_lp = sequence_logprob / len(tokens)
if avg_lp < -2.5:                    # equivalent to PPL > 12
    flag_as_potential_hallucination()

Heuristic 2: low-confidence token count#

low_conf_count = sum(1 for t in tokens if t.logprob < -3)
if low_conf_count > len(tokens) * 0.2:    # %20+ low-confidence
    flag()

Heuristic 3: named entity check#

# Hugging Face NER ile entity extract
entities = ner_pipeline(text)
for ent in entities:
    # Token range bul
    tokens_in_ent = find_tokens_in_range(ent["start"], ent["end"], content)
    avg_lp = mean(t.logprob for t in tokens_in_ent)
    if avg_lp < -3:
        flag(f"Suspicious entity: {ent['word']}")

Heuristic 4: SelfCheckGPT (Manakul 2023)#

1. Aynı prompt'a N=10 sample (T=0.7)
2. Pairwise NLI veya BERTScore similarity
3. Cevapların %80'i tutarsız → hallucination şüphesi

Production combo#

score = 0
if avg_logprob < -2: score += 1
if low_conf_ratio > 0.2: score += 1
if entity_low_conf: score += 2
if self_check_consistency < 0.7: score += 2

if score >= 3:
    flag_high_hallucination_risk()

Türkçe için#

İngilizce: avg_lp threshold = -2.5
Türkçe:    avg_lp threshold = -3.5

7. Token-Level Entropy ve Şüphe Noktaları#

def find_uncertainty_hotspots(content, threshold=1.5):
    """
    Cevapta yüksek entropi noktalarını bul.
    """
    hotspots = []
    for i, tok in enumerate(content):
        # Top-k entropy
        probs = [math.exp(t.logprob) for t in tok.top_logprobs]
        total = sum(probs)
        probs = [p/total for p in probs]
        entropy = -sum(p * math.log2(p + 1e-10) for p in probs)
        if entropy > threshold:
            hotspots.append({
                "position": i,
                "token": tok.token,
                "entropy": entropy,
                "alternatives": [(t.token, math.exp(t.logprob)) for t in tok.top_logprobs[:3]]
            })
    return hotspots

Pratik kullanım#

• Citation enforcement: hotspot tokens'larda factual claim varsa, RAG ile verify
• Human-in-the-loop: yüksek entropi cevaplar review için flag
• Active learning: bu örnekleri fine-tune dataset'ine ekle (uncertainty-based sampling)

8. Anomaly Detection — Garip Pattern'leri Yakalama#

1. Sudden confidence drop#

Normal: -0.5, -0.8, -0.3, -1.0, -0.6...
Anomaly: -0.5, -0.8, -0.3, -8.5, -0.6...    # tek bir token -8.5

2. Sustained low confidence#

Normal: -0.5, -0.8, -0.3, -1.0...
Anomaly: -3.5, -4.2, -3.8, -4.5, -3.9...    # tüm cevap düşük

3. Repetition pattern#

4. Glitch tokens#

Production dashboard#

class ResponseMetrics:
    avg_logprob: float
    min_logprob: float
    max_token_entropy: float
    sudden_drops: int          # logprob diff > 5 between adjacent
    low_conf_tokens_pct: float
    hallucination_score: int   # 0-5

9. Prompt Diagnostics — Hangi Token Bilgi Vermiyor?#

Yöntem: leave-one-out logprob#

def prompt_attribution(prompt, expected_response, model):
    """
    Her token'ı 'sil' ve response'un logprob'una etkisini ölç.
    Etkisi büyük olanlar 'önemli', küçük olanlar 'gereksiz'.
    """
    full_lp = get_response_logprob(prompt, expected_response)

    tokens = tokenize(prompt)
    attributions = []
    for i in range(len(tokens)):
        masked = tokens[:i] + tokens[i+1:]
        masked_lp = get_response_logprob(detokenize(masked), expected_response)
        delta = full_lp - masked_lp
        attributions.append({"token": tokens[i], "importance": delta})

    return sorted(attributions, key=lambda x: -x["importance"])

Pratik#

Modül bağlantısı#

10. Semantic Confidence — Multi-Sample Tutarlılık#

SelfCheck-NLI (Manakul 2023)#

1. Aynı prompt'a N=5 sample (T=0.7)
2. Her sample içindeki **factual claim'leri** çıkar
3. Diğer N-1 sample'ı reference olarak kullan
4. Her claim için: kaç reference onayla / kaç reddediyor (NLI ile)
5. Score = onaylama_orani

SelfCheck-BERTScore#

Production#

• High-stakes Q&A: minimum 5 sample
• Threshold: %80 tutarlılık → güvenilir
• < %50 → hallucination probable

Maliyet#

• Medical: zorunlu
• Legal: zorunlu
• Customer support: tartışmalı
• Casual chat: gereksiz

11. Production Monitoring — Real-Time Dashboards#

Önerilen metric'ler#

Dashboard panels#

1. Time-series: avg logprob over time (per hour/day)
2. Histogram: response logprob distribution
3. Heatmap: token position × confidence (hangi pozisyonda kararsızlık?)
4. Alert feed: real-time anomaly detection

Langfuse pattern#

from langfuse import Langfuse
langfuse = Langfuse(public_key=..., secret_key=...)

trace = langfuse.trace(name="llm-response")
generation = trace.generation(
    name="primary-response",
    model="gpt-5-mini",
    input=prompt,
    output=response_text,
    usage={"input_tokens": ..., "output_tokens": ...},
    metadata={
        "avg_logprob": avg_lp,
        "low_conf_count": low_conf,
        "entropy_max": max_entropy,
        "hallucination_score": h_score,
    },
)

12. logprobs'un Söylemediği#

1. Internal "reasoning"#

2. Cross-token dependency#

"Ankara is in Spain." → tüm tokenlar yüksek logprob alır
ama anlam yanlış

3. Calibration#

4. Confidence vs correctness#

5. Causal vs spurious patterns#

Bilinçli kullanım#

13. Mini Egzersizler#

1. logprob → probability: logprob = -2.3, hangi probability'e karşılık? Sequence'in logprob toplamı -23, length 10. Perplexity?
2. MCQ scoring pratik: 4 seçenekli soruya cevap olarak A=-0.5, B=-1.2, C=-2.0, D=-3.1 logprob. Probabilities? Confidence?
3. Hallucination heuristic: Avg logprob -2.8, entity logprobs [-0.5, -1.0, -4.5]. Hallucination şüphesi seviyesi?
4. Token entropy hesabı: Top-3 logprobs [-0.5, -2.0, -3.5]. Token entropy?
5. SelfCheck threshold: 10 sample'dan 6'sı tutarlı, 4'ü farklı. Bu cevaba güvenir misin? Threshold önerisi?

Bu Derste Neler Öğrendik?#

Sıradaki Ders#