12  Metin Sınıflandırma

Bölüm durumu: çevrildi. Bu sayfadaki her sayı, Bölüm 4’ün aynı bölmesi üzerinde ölçüldü — aynı 40.000 eğitim ve 10.000 test yorumu; yeniden çekilmiş değil, geri kazanılmış hâlleriyle. Nedenini Bölüm 12.1 anlatıyor. LLM karşılaştırmaları (Bölüm 12.8 ve Bölüm 12.9), aynı test diliminden tabakalı 2.000 belgelik bir altörneklem kullanıyor ve yarışan bütün modeller bu altörneklem üzerinde yeniden puanlandı; Bölüm 12.8 bunun nedenini ve ölçümün çözünürlüğünden ne kaybettirdiğini açıklıyor. Veri: Hugging Face üzerinde fthbrmnby/turkish_product_reviews; indirildiği hâliyle 235.165 satır, metni birebir aynı olan tekrarlar temizlendikten sonra 233.508. Yazılım: Python 3.14.5 üzerinde scikit-learn 1.9.0, transformers 5.15.0, PyTorch 2.13.0, imbalanced-learn 0.14.2, scipy 1.18.0; encoder eğitimi bir Apple M serisi GPU’da; yerel LLM’ler ollama 0.24.0 üzerinden.

Öğrenme hedefleri. Bu bölümün sonunda şunları yapabileceksiniz:

• daha büyük bir şeye geçmeden önce güçlü bir seyrek (sparse) baseline (taban model) kurmak ve onun yalnızca en büyük etiket bütçesinde değil, her etiket bütçesinde neye mal olduğunu söylemek;
• bir encoder’a (kodlayıcı) fine-tuning (ince ayar) uygulamak ve hangi bütçeden itibaren maliyetine değdiğini belirlemek;
• modeliniz iyileştiğinde kıpırdayan bir metrikle kıpırdamayan bir metriği ayırt etmek;
• sınıf dengesizliğini veriyi yeniden örnekleme sorunu değil, bir karar eşiği sorunu olarak ele almak ve bunu bir ölçümle savunmak;
• modelinizin olasılık dediği sayının gerçekten olasılık olup olmadığını sınamak ve olmadığında onarmak;
• bir maliyet matrisini eşiğe çevirmek ve bunun tahmin yürütmeye göre ne kadar tasarruf ettirdiğini söylemek;
• fine-tune edilmiş küçük bir modelle prompt (istem) verilen bir LLM arasında ölçülmüş doğruluk, gecikme ve maliyete bakarak karar vermek;
• hata analizini tek tük örneklere dayanmak yerine tekrarlanabilir bir süreç olarak yürütmek.

12.1 Yenilmesi gereken tek sayı

Bölüm 4 bir lider tablosuyla bitmişti. Yedi temsil, 40.000 Türkçe ürün yorumu, 10.000’lik tek bir ayrılmış (held-out) küme ve bir kazanan: kelime unigram ve bigram’ları üzerinde tf-idf, sınıf ağırlıklı bir lojistik regresyona verilmiş hâliyle, 76,21 macro-F1 ile. Referans noktasının kendisinin sınıf ağırlıklı olması önemli ve Bölüm 12.5 bunun hesabını soracak. Bu bölümün işi, onu geçmek için ne gerektiğini ve her artışın neye mal olduğunu bulmak.

macro-F1 — F1 puanını her sınıf için ayrı hesaplayıp ağırlıksız ortalamalarını almak. Nadir bir sınıf, yaygın bir sınıf kadar sayılır; bu derlemde doğruluk sapasağlam dururken macro-F1’in dağılmasının nedeni de budur. ↩︎

Bu çerçeve yalnızca test kümesi harfi harfine aynı olduğunda işe yarar. Başka bir 10.000 yorum üzerinde puanlanan bir model, 76,21 ile yarışmıyor; ölçülmemiş bir sayıyla yarışıyor. Dolayısıyla bu bölümün ilk işi Bölüm 4’ün bölmesini yeniden kurmak ve doğrulamak oldu.

Bu beklenenden zor çıktı ve zorluğun kendisi ilk ders.

12.1.1 Bir bölmeyi parmak izinden geri kazanmak

Bölüm 4 altörneklemini “50.000 satır, tabakalandırılmış, seed 42” diye kaydetmişti; seed (tohum), rastgele sayı üretecinin başlangıç değeri. Bölüm 11 da altörneklemini aynı şekilde kaydetti. İkisi de doğru. Ama bunlar iki farklı örneklem, çünkü “seed 42 ile tabakalandırılmış” tek bir yordamı adlandırmıyor — birbirinden farklı sonuçlar veren bir yordam ailesini adlandırıyor.

Bölmeyi yeniden kurmaya yönelik ilk deneme, altörneklemi Bölüm 11’in yaptığı gibi grup grup çekti ve şunu üretti:

                             dims      acc   macroF1   negF1
target (4. bölüm)         101,659    92.57     76.21   56.47
groupby.sample            100,350    92.21     74.65   53.55

Öne çıkan istatistiklerin hepsi yakın ve hepsi yanlış. Bir okur bunu fark etmezdi; 74,65 de 76,21 de “yaklaşık 75”e yuvarlanıyor. Ama vectorizer’ın (vektörleştirici) boyut sayısı bir istatistik değil, bir parmak izi: filtreden geçen 101.659 farklı n-gram, eğitim yarısında hangi belgelerin bulunduğuna dair bir olgu. 50.000 satırlık iki farklı örneklem bu sayıyı tesadüfen paylaşmaz.

Bu yüzden örneklemi oluşturmanın dört yolunu denedik ve her birini o parmak iziyle karşılaştırdık:

                             dims      acc   macroF1   negF1
target                    101,659    92.57     76.21   56.47
groupby.sample            100,350    92.21     74.65   53.55
train_test_split 50k      101,659    92.57     76.21   56.47   ← birebir eşleşme
train_test_split + shuffle 102,221   92.26     75.20   54.63
plain sample 50k          101,539    91.68     74.40   53.36

Biri, dört sayının dördünü birden tutturdu. Bölüm 4 50.000’liğini tek bir tabakalı train_test_split ile çekmiş ve aşağıdaki bütün deneyler o geri kazanılmış bölme üzerinde koşuyor.

Kıl payı ıskalayan satıra dikkat edin. “plain sample 50k”, hedefe 120 boyut ve bir doğruluk puanından az (92,57’ye karşı 91,68) uzaklıkta — dikkatsiz bir kontrolün kabul edeceği kadar yakın. Ama eşleşmenin neden ikna ettiğine dikkat edin: bunlar birbirinden bağımsız dört tanık değil. dims, hangi belgelerin eğitim yarısına düştüğünün deterministik bir fonksiyonu; üç puan ise tek bir eğitilmiş modelin tek bir test kümesi üzerindeki üç okuması, yani birlikte hareket ediyorlar. Argüman dört uyuşma değil, tek bir çok keskin uyuşma: 101.659, iki farklı 50.000 satırlık örneklemin paylaşması için hiçbir sebebi olmayan altı haneli bir sayı. Kıl payı ıskalayan satır da daha kaba istatistiklerin bu iki örneklemi ayıramayacağını gösteriyor. Tek çözümün bu olduğunu da kanıtlamadık — akla yatkın dört kurulumu sıraladık ve biri birebir tuttu. Bir gün birinin deney kurulumunu geri kazanmanız gerekirse, elinizde yazılı olan niceliği değil, tespit etmeye çalıştığınız şeye en duyarlı niceliği seçin.

Yan ürün, başka bir bölüme yapılan bir düzeltme oldu. İki altörneklemi kesiştirmek, Bölüm 11 ile Bölüm 4’ün 50.000’er belgeden 23.819’unu paylaştığını gösterdi — %47,6. İkisi de tabakalı, ikisi de seed 42 kullanıyor, ikisi de tam olarak 46.839 olumlu ve 3.161 olumsuz yorum içeriyor; yine de ortak kısımları yarıdan az. Bölüm 11’in kenar notu artık bunu söylüyor. Hiçbir doğrulayıcı bunu yakalayamazdı; yalnızca iki kümeyi kesiştirip saymak yakalardı.

Ve bu geriye dönük iz sürme aslında gereksizdi; hikâyenin söylemediği ders de bu. Bölüm 4’ün kaydettiği şey düzyazıydı — “tabakalandırılmış, seed 42”. Kaydetmesi gereken şey, çağrının kendisi ve sonucun bir parmak izi:

train_df, test_df = train_test_split(
    df, train_size=50_000, stratify=df["label"], random_state=42)
print(hashlib.sha256(
    ",".join(map(str, sorted(train_df.index))).encode()).hexdigest()[:12])

Bölüm 4 artık ikisini de basıyor. Üç bölüm bu tek çağrıya dayanıyor ve biri kimse fark etmeden farklı bir örneklem çekti. Çağrıyı basın, hash’i basın; parmak izi bir dedektiflik hikâyesi olmaktan çıksın.

12.1.2 Bölme ve bu bölümün eklediği dilim

Bölüm 4 iki dilim kullandı: train ve test. Bu bölüm ise üç dilime ihtiyaç duyuyor ve bölümdeki sayılara güvenilebilmesinin tek nedeni de o fazladan dilim: eşiklerin ayarlandığı, ne eğitimde ne de son puanlamada kullanılan ayrı bir dilim.

rows as downloaded      235,165
after de-duplication    233,508   (1,657 exact duplicates)
stratified subsample     50,000   46,839 positive   3,161 negative

  train                  40,000   37,471 positive   2,529 negative
    fit                  32,000   29,977 positive   2,023 negative
    cal                   8,000    7,494 positive     506 negative
  test                   10,000    9,368 positive     632 negative

Bölüm 4 train ve test’i kullandı. Bu bölüm train’i bir kez daha ikiye ayırıyor: 32.000 belgelik bir fit dilimi ve 8.000 belgelik bir cal dilimi; çünkü bölümün ölçtüğü şeylerden üçü — bir karar eşiği (decision threshold), bir kalibrasyon eşlemesi, maliyet açısından en iyi çalışma noktası — veriden ayarlanan nicelikler ve test üzerinde ayarlanmamaları gerekiyor.

decision threshold (karar eşiği) — bir puanı etikete çeviren kesme noktası. Neredeyse her sınıflandırıcı varsayılan olarak 0,5 ile geliyor, ama 0,5 bir ölçüm değil bir gelenek: hataların size neye mal olduğuna bakarak, ayrılmış veri üzerinde seçmeniz beklenen serbest bir parametre. ↩︎

Bu bölümdeki her eşik cal üzerinde seçilip test üzerinde raporlanıyor. Bunun bu bölümdeki her maliyet karşılaştırmasına taşınacak bir sonucu var: o 8.000 cal belgesi etiketli, yani etiket bütçesinin parçası. Kalibrasyon dilimine ihtiyaç duyan bir yöntem, duymayan birinden daha çok etikete mal olur ve yalnızca eğitim kümesini fiyatlandıran bir karşılaştırma maliyeti eksik gösterir. Bir sayı test üzerinde ayar yapılarak elde edilmişse oracle diye işaretleniyor ve yalnızca pişmanlığı (regret) ölçeceğimiz bir üst sınır olarak kullanılıyor. Maliyetleri ele aldığımız kısımda (Bölüm 12.7) en belirleyici olan da bu ayrım olacak.

Ve bu bölümdeki her eşik şikâyet tarafında ifade ediliyor: \(P(\text{şikâyet})\) değeri \(t\)’yi geçtiğinde yorumu işaretliyoruz. Yani düşük bir \(t\), daha çok şikâyet yakala demek. Başka yerlerde öteki uzlaşımla karşılaşacaksınız — aynı çalışma noktası memnun tarafında 0,834 diye yazılır — o yüzden biriyle sayı karşılaştırmadan önce hangi taraftan konuştuğunuzu netleştirin. Baştan bir kez ilan edilen tek bir uzlaşım, sonradan gösterilecek her türlü özenden daha değerlidir.

Hangi dilim neye karar vermeye yetkili

Orta katman, Bölüm 4’ün ihtiyaç duymadığı şey. Sıradan bir kurulumda veriden kestirilen nesneler — ağırlıklar ve vectorizer sözlüğü — eğitim sırasında kestirilir. Bu bölüm bunlara üç nesne daha ekliyor ve üçü de eğitimden sonra, sınıflandırıcının hiç görmediği veri üzerinde kestiriliyor. cal dilimi olmasa, bu bölümdeki her eşik ve her kalibrasyon eğrisi kendi ayarlandığı veri üzerinde rapor veriyor olurdu.

8.000 belge keyfî bir boyut değil. Bölüm 12.6 bu dilim üzerinde izotonik regresyonu ayarlıyor. Niculescu-Mizil ile Caruana’nın bulgusuna göre izotonik regresyon, parametrik bir sigmoid’i geçebilmek için kabaca birkaç yüz ile bin arası kalibrasyon noktasına ihtiyaç duyuyor; bunun altında aşırı öğreniyor (Niculescu-Mizil ve Caruana 2005). 8.000’de — üstelik azınlık sınıfından 506 örnekle — onların sonucunun izotonik için güvenli dediği bölgede rahatça duruyoruz. Bunu yalnızca onların bulgusuna dayanarak değil, kendi ölçümümüz de aynı sonucu verdiği için söylüyoruz (Bölüm 12.6).

Baseline birebir yeniden üretiliyor:

tf-idf 1-2 gram + LogisticRegression(class_weight="balanced"),
101,659 features, 31.7 non-zeros per row

accuracy      92.57
macro-F1      76.21
complaint P   44.84    R 76.27    F1 56.47

                 predicted
              complaint  satisfied
 complaint         482        150
 satisfied         593      8,775

12.1.3 Bu bölüm nereye varıyor

İşten önce varış noktası. Aşağıdaki her satır bölümün ilerisinde ölçülüyor ve bunların birkaçı, literatürün beklemenize yol açacağı şeyin tam tersi çıktı. Tablodaki bazı terimler (kalibrasyon hatası, AUROC, eşleştirilmiş bootstrap) ancak onları ölçen kısımlarda tanımlanıyor; tabloyu şimdi genel hatlarıyla okuyun ve bölümün sonunda ona geri dönün.

Bu bölümün ölçtükleri

ne sorduk	ne geldi
Fine-tuning, 40.000 etiketlik tf-idf’i geçiyor mu?	Evet — 2.000 etiketle
Öyleyse seyrek baseline’ın modası geçti mi?	Hayır. ~1.000 etiketin altında kazanıyor ve 1,2 saniyede eğitiliyor
Yeniden örnekleme sınıf dengesizliğini çözüyor mu?	Hayır. Tek bir eşiği kaydırmak, en iyisiyle aynı sonucu hiçbir ek maliyet olmadan verdi
Sınıf ağırlıklandırma bir bedel ödetiyor mu?	Evet: kalibrasyon hatasını 3,6 katına çıkardı
Modelin “olasılığı” gerçekten olasılık mı?	Siz düzeltene kadar hayır — ve düzeltmesi iki parametre
Ders kitabındaki maliyet-optimal eşik işe yarıyor mu?	Yalnızca kalibre puanlarda. Ham puanlarda %56’ya varan fazla harcama
Doğruluk size hangi eşiği seçeceğinizi söylüyor mu?	Hayır. Recall (duyarlılık) 48 puan oynarken o 1,3 puan oynadı
7,35 puanlık bir model yükseltmesi saf kazanç mı?	Hayır. 332 test belgesini düzeltti, 149’unu bozdu
Encoder, tf-idf’ten her durumda daha iyi mi?	Hayır — uzun belgelerde daha iyi, 1,88×’e karşı 1,18×
Geriye kalan hatalar modelin suçu mu?	Çoğu zaman değil. Modelin en emin olduğu hatalar etiket hataları
Promptlanan bir LLM, fine-tune edilmiş bir encoder’ı geçebiliyor mu?	Evet — 1.000 etikette ve altında. 2.000’de 0,08 puan farkla berabere
Prompt’u İngilizce yazmak yardım ediyor mu?	Yalnızca model zayıfsa: 3B’de +16,90 puan, 9B’de +0,54
Kelimelerle ifade edilen bir güven düzeyi bir anlam taşıyor mu?	Ortalamada evet, +0,58. Dedektör olarak, 0,843’e karşı AUROC 0,667
2.000 etiketteki beraberlik gerçek bir seçim mi?	Maliyeti hesaba katınca değil. LLM belge başına 142× daha pahalı

Neye bakacağız. Önce bölümdeki her sonucun kıyaslandığı sayı; bu derlemde henüz hiçbir model yokken utanç verici ölçüde yüksek. Sonra bir sınıflandırıcı kurmanın iki yolu — göründüğünden zor yenilen seyrek bir baseline ve fine-tune edilmiş bir encoder — ve onları birbirinden ayıran metrikler, çünkü doğruluk ayırmayacak. Sonra çoğu anlatımın atladığı kısım: bir modelin size verdiği sayının bir olasılık olup olmadığı ve bu sayıyı, bir hatanın gerçekte neye mal olduğunu kullanarak nasıl bir karara çevireceğiniz. Son olarak bölümün varlık sebebi olan karşılaştırma — küçük modele karşı LLM — ve onu karara bağlayan iki eksen.

12.2 Geçilmesi zor baseline’lar

Parametre eklemeden önce, ucuz olan şeyin başkasının bütçesinde değil sizin etiket bütçenizde ne yaptığını öğrenin. Bölüm 4 bir eğrinin tek bir noktasını raporlamıştı. İşte eğrinin kendisi: aynı vectorizer, aynı sınıflandırıcı, aynı test kümesi, train’in tabakalı alt kümeleri üzerinde eğitilerek:

labels   macro-F1   complaint-F1   features   fit time
   200      55.46          14.63        720       0.1s
   500      60.82          25.32      1,762       0.1s
 1,000      61.60          27.03      3,458       0.1s
 2,000      67.42          38.77      6,586       0.2s
 5,000      72.77          49.18     15,828       0.3s
10,000      73.44          50.87     29,149       0.4s
20,000      75.00          54.03     54,822       0.6s
40,000      76.21          56.47    101,659       1.2s

Bu tablodaki üç şey, öne çıkan sayıdan daha değerli.

Eğri 40.000’de hâlâ tırmanıyor. 20.000 etiketten 40.000’e çıkmak 1,21 macro-F1 puanı kazandırdı. Bir kez daha katlamak muhtemelen benzer bir şey kazandırırdı. Burada hiçbir şey doyuma ulaşmadı; dolayısıyla “bütün verimizi kullandık” cümlesi yöntem hakkında değil, bütçe hakkında bir cümle.

Kazancın neredeyse tamamı azınlık sınıfında. Taramanın tamamında macro-F1 20,75 puan yükseliyor; şikâyet-F1 ise 41,84. Çoğunluk sınıfı daha 200 etiketteyken esasen çözülmüştü ve çözülmüş kaldı. Bir sınıf verinizin %93,7’siyse, ortalama metrik esasen kalan %6,3 hakkında rapor veriyordur — Bölüm 4’ün doğruluğu değil macro-F1’i kullanmasının nedeni budur ve Bölüm 12.4 aynı noktaya daha sert biçimde geri dönüyor.

Taramanın tamamı üç saniye. O sütundaki her eğitim koşusu, bir dizüstü CPU’sunda yaklaşık bir saniye ya da daha az sürüyor; toplamı üç saniye. Seyrek baseline hakkında başka ne doğru olursa olsun, onu çalıştırmaya gücünüz yeter — ve daha pahalı herhangi bir şeyden gelen bir sayıya inanmadan önce çalıştırmalısınız.

features sütunu, tf-idf’in aslında ne olduğunu hatırlatıyor. 200 etikette filtreden geçen 720 n-gram var, çünkü min_df=2 bir kez görülen her şeyi atıyor. Model kendi tercihiyle “küçük” değil; görmesine izin verilen sözlük küçük olduğu için küçük. Performansının bu kadar yumuşak biçimde düşmesinin nedeni de bu — aşırı öğrenilecek bir şey yok.

12.3 Encoder modelleri fine-tune etmek

Rakip, dbmdz/bert-base-turkish-cased olarak yayımlanan Türkçe BERT, yani BERTurk (Schweter 2020).

BERTurk 2020 tarihli bir checkpoint (kontrol noktası). Onu, yaygın kullanılan en güçlü Türkçeye özgü encoder olduğu için seçtik — frontier (en ileri) model olduğu için değil. 2024–2026’da encoder’lara dönen ilgi, BERT-base reçetesini benzer bir büyüklükte (ModernBERT-base’de ~150M parametre) rotary embedding (dönel konum kodlaması), unpadding (dolgu token’larını hesaba katmama) ve 8.192 token’lık bağlamla yeniden kurdu. ModernBERT’in kendisi (Warner vd. 2025) İngilizce ve kod üzerinde eğitildi; onu izleyen çok dilli aileler (ör. mmBERT) ise Türkçeyi de kapsıyor ve belirgin biçimde daha hızlı eğitiliyor. Bu bölümün maliyetle ilgili iki ana bulgusu (eğitimde 970×, serviste 142×) bu modellerden biriyle değişebilirdi. Taramayı yeniden çalıştırmadık; 970 kat rakamının sınırı da bu.

BERTurk, 32.000 token’lık bir sözlükle ve bir TPU v3-8 üzerinde, kabaca 35 GB ve 4,4 milyar token’lık Türkçe metinle ön eğitildi: filtrelenmiş OSCAR, bir Wikipedia dökümü, OPUS derlemleri ve Kemal Oflazer’in katkıda bulunduğu bir derlem.

Model kartı 2M eğitim adımı diyor; deponun hızlı başvuru notu ise --num_train_steps=3000000 geçiyor. Hangisinin doğru olduğunu çözemedik, bu yüzden bölüm buna hiçbir yerde dayanmıyor. Model kartı ayrıca token sayısını “44,04,976,662” diye basıyor; bu, 4.404.976.662 için bir basamak gruplama hatası — model kartlarının veri değil düzyazı olduğuna dair küçük bir hatırlatma.

Checkpoint’i yükleyip saymak 110.618.882 parametre veriyor: 24.972.288’i embedding (gömme) tablosunda, 85.054.464’ü on iki encoder katmanında, 590.592’si pooler’da ([CLS] vektörünü dönüştüren katman) ve kalan 1.538’i, attığımız ön eğitim head’inin yerine geçen iki sınıflı sınıflandırma head’inde (çıktı katmanı; \(768 \times 2\) ağırlık artı iki bias (sabit terim)). Bu dört sayının toplamı tam tutuyor. O embedding sayısına dikkat edin — modelin %22,6’sı bir arama tablosu ve bunun nedeni sözlüğün 32.000 token genişliğinde olması.

12.3.1 Ölçümle verilmiş bir dizi uzunluğu kararı

Attention’ın (dikkat mekanizması) maliyeti dizi uzunluğuyla karesel artar (Bölüm 7); dolayısıyla max_length, eğitim maliyetini en çok etkileyen ayar. Alışılmış tavsiye 512, yani modelin sınırı. Derlemin gerçekte neye ihtiyacı olduğu, BERTurk alt kelimeleri cinsinden şöyle:

median    29 subwords
p95       86
p99      146
max      466

truncated at max_length=64    10.97% of documents
truncated at max_length=128    1.54%
truncated at max_length=192    0.36%
truncated at max_length=256    0.11%
truncated at max_length=512    0.00%

Bu sayılar 40.000 belgelik eğitim dilimi üzerinden hesaplandı ve [CLS] ile [SEP] token’larını içeriyor, çünkü GPU’nun gerçekte doldurup kırptığı şey bu. Test dilimi de aynı davranıyor — medyan 29, p95 87 — dolayısıyla karar hangi dilimi ölçtüğünüze bağlı değil.

Biz 128 kullanıyoruz. Yorumların %1,54’ünü kırpıyor ve 512’nin attention hesabının on altıda birine mal oluyor. 512’yi “garanti olsun diye” seçmek, yüzde ikiden az belgeyi korumak uğruna dizi uzunluğunu dörde katlardı; üstelik o belgeler zaten lafı uzattıkları için uzun. Bu tabloyu üreten beş dakikalık ölçüm, bölümdeki getirisi en yüksek beş dakika.

12.3.2 Öğrenme eğrisi

Aynı bütçeler, aynı alt kümeler, aynı test kümesi. Sınıf ağırlıklı çapraz entropi, 2e-5’te AdamW, batch (yığın) 32, max_length 128, adımların ilk %10’unda doğrusal ısınma. 2.000 ve altındaki bütçeler 20 epoch (devir) alıyor, daha büyük bütçeler 3 — aksi hâlde küçük koşular o kadar az gradyan güncellemesi görürdü ki bütçeyi değil, bütçe takvimini ölçüyor olurduk.

labels   macro-F1   complaint-F1   complaint-P   complaint-R   steps
   200      54.31          12.83         20.49          9.33     140
   500      56.46          16.37         40.12         10.29     320
 1,000      71.57          45.95         63.76         35.92     640
 2,000      79.61          61.63         66.48         57.44   1,260
 5,000      81.27          65.12         60.22         70.89     471
10,000      82.71          67.50         71.30         64.08     939
20,000      83.71          69.41         72.26         66.77   1,875
40,000      85.02          71.92         72.32         71.52   3,750

Sayıları okumadan önce iki çekince ve birincisi burada olmayan şeyle ilgili. Bu eğrideki her nokta, tek bir seed ile yapılmış tek bir eğitim koşusu. Bu, en çok küçük bütçelerde önemli: rastgele ilklendirilmiş bir sınıflandırma head’i ve 500 örnekle macro-F1 seed’den seed’e birkaç puan mertebesinde oynar; yani 500 ile 1.000 arasındaki 15,1 puanlık sıçramayı bir kez ölçtük. 500, 1.000 ve 2.000’de üç seed, kesişime bir hata çubuğu koyardı ve bu alt bölümün en çok ihtiyaç duyduğu ölçüm de o. Bölümün ilerisindeki bootstrap aralıklarının neyi ölçtüğüne de dikkat edin. Bir bootstrap aralığı, test belgelerini yerine koyarak defalarca yeniden çeker, metriği her çekilişte yeniden hesaplar ve çıkan değerlerin ortadaki %95’ini raporlar. Bu bölümdeki her bootstrap aralığı test kümesini yeniden örnekliyor, optimize ediciyi değil. Yani bu aralıklar değerlendirme gürültüsünü tarif ediyor, eğitim gürültüsü hakkında hiçbir şey söylemiyor.

İkinci çekinceyi steps sütunu görünür kılıyor. Epoch takvimi 2.000’de değişiyor; yani 2.000 etiketli model 1.260, 5.000 etiketli model yalnızca 471 güncelleme alıyor — örnek başına neredeyse yedi kat daha fazla gradyan güncellemesi. Şikâyet precision’ının (kesinlik: işaretlenenlerin gerçekten şikâyet olan payı) o tek adımda 66,48’den 60,22’ye düşmesinin ve 5.000 etiketli modelin ortak altörneklemde (Bölüm 12.8) 2.000 etiketli modelin altında kalmasının (81,21’e karşı 82,00) en olası sebebi bu. Bütçe büyüdükçe düşen bir öğrenme eğrisi normal değildir ve ilk şüphelenilecek şey bir takvim değişikliğidir. Bu bölümün öne çıkan iki kesişimi de 2.000’de, yani 20 epoch takvimindeki en büyük bütçede duruyor. İkisini ayırmak için 5.000’i 20 epoch’la yeniden çalıştırmadık; o yüzden aşağıdaki her kesişimi bu takvimde diye okuyun.

Üç okuma çıkıyor ve üçüncüsü bir projeyi planlama şeklinizi değiştiren okuma.

Encoder eğrinin dibinde kaybediyor. 200 etikette BERTurk, tf-idf’in 55,46’sına karşı 54,31 alıyor; 500’de 60,82’ye karşı 56,46. 4,4 milyar token Türkçe üzerinde ön eğitilmiş 110 milyon parametreli bir model, Türkçede, 500 örnekle bir kelime torbası (bag-of-words) modelinden daha kötü. Ortada bir bozukluk yok: sınıflandırma head’i rastgele ilklendiriliyor. İçinde 32 şikâyet bulunan 500 örnek ise bu boyutta bir ağı, önce aşırı öğrenmesine yol açmadan yararlı bir bölgeye taşıyacak kadar sinyal içermiyor.

Seyrek–encoder kesişimi 500 ile 1.000 etiket arasında ve ani. Bu tek katlamada BERTurk 15,1 macro-F1 puanı kazanıyor, tf-idf 0,8. Şikâyet recall’u (gerçek şikâyetlerden yakalananların payı) %10,29’dan %35,92’ye çıkıyor. Bu aralıkta bir yerde model, çoğunluk sınıfını tahmin edip arada bir kazara şikâyet demekten vazgeçiyor; bir şikâyetin ne olduğuna dair bir temsil edinmeye başlıyor.

2.000 etiketteki BERTurk, 40.000 etiketteki tf-idf’i geçiyor. 76,21’e karşı 79,61 — yirmi kat az etiketle daha iyi bir model. Etiketleme sizin darboğazınızsa, ki genellikle öyledir, bu oran bir planlama toplantısına götürülecek sayıdır. Eşit bütçede, 40.000 etikette, fark 8,81 macro-F1 puanı ve 15,45 puan şikâyet-F1 — insanın gerçekte deneyimlediği sayı ikincisi.

bertRows = [
  {n: 200,   bert: 54.31, bert_negf1: 12.83, tfidf: 55.46, tfidf_negf1: 14.63, steps: 140},
  {n: 500,   bert: 56.46, bert_negf1: 16.37, tfidf: 60.82, tfidf_negf1: 25.32, steps: 320},
  {n: 1000,  bert: 71.57, bert_negf1: 45.95, tfidf: 61.60, tfidf_negf1: 27.03, steps: 640},
  {n: 2000,  bert: 79.61, bert_negf1: 61.63, tfidf: 67.42, tfidf_negf1: 38.77, steps: 1260},
  {n: 5000,  bert: 81.27, bert_negf1: 65.12, tfidf: 72.77, tfidf_negf1: 49.18, steps: 471},
  {n: 10000, bert: 82.71, bert_negf1: 67.50, tfidf: 73.44, tfidf_negf1: 50.87, steps: 939},
  {n: 20000, bert: 83.71, bert_negf1: 69.41, tfidf: 75.00, tfidf_negf1: 54.03, steps: 1875},
  {n: 40000, bert: 85.02, bert_negf1: 71.92, tfidf: 76.21, tfidf_negf1: 56.47, steps: 3750}
]

viewof curveMetric = Inputs.radio(
  new Map([
    ["Macro-F1 — iki sınıfın ortalaması", "macro"],
    ["Şikâyet F1 — azınlık sınıfı tek başına", "negf1"]
  ]),
  { value: "macro", label: "" }
)

curvePlot = {
  const suffix = curveMetric === "macro" ? "" : "_negf1";
  const long = bertRows.flatMap(d => [
    {n: d.n, model: "tf-idf + LR", y: curveMetric === "macro" ? d.tfidf : d.tfidf_negf1},
    {n: d.n, model: "BERTurk fine-tune", y: curveMetric === "macro" ? d.bert : d.bert_negf1}
  ]);
  return Plot.plot({
    width: 700,
    height: 360,
    marginLeft: 60,
    marginBottom: 48,
    x: { label: "etiketli eğitim belgesi", type: "log",
         ticks: [200, 500, 1000, 2000, 5000, 10000, 20000, 40000],
         tickFormat: d => d.toLocaleString("tr-TR"), grid: true },
    y: { label: curveMetric === "macro" ? "10.000 belgelik test kümesinde macro-F1"
                                        : "10.000 belgelik test kümesinde şikâyet F1",
         domain: [0, 90], grid: true },
    color: { legend: true, domain: ["tf-idf + LR", "BERTurk fine-tune"],
             range: ["#1F4E79", "#B3453E"] },
    marks: [
      curveMetric === "macro"
        ? Plot.ruleY([48.37], { stroke: "currentColor", strokeDasharray: "4 3" })
        : null,
      curveMetric === "macro"
        ? Plot.text([{n: 300, y: 48.37}], { x: "n", y: "y", text: ["her zaman “memnun”"],
            dy: -9, fill: "currentColor", textAnchor: "start" })
        : null,
      Plot.ruleX([700], { stroke: "#2E7D6F", strokeDasharray: "3 3", strokeOpacity: 0.6 }),
      Plot.line(long, { x: "n", y: "y", stroke: "model", strokeWidth: 2.5 }),
      Plot.dot(long, { x: "n", y: "y", fill: "model", r: 4,
        title: d => `${d.model}\n${d.n.toLocaleString("tr-TR")} etiket\n${d.y.toFixed(2)}` })
    ].filter(d => d)
  });
}

Camgöbeği çizgi kesişim bölgesini işaretliyor. Şikâyet F1’e geçin ve iki eğrinin aynı yerde kesiştiğini ama sonrasındaki açıklığın kabaca iki kat geniş olduğunu fark edin: 40.000 etikette macro-F1 8,81 puan, şikâyet-F1 ise 15,45 puan ayrışıyor. %93,7’lik bir çoğunluk sınıfı üzerinden ortalama almak, encoder’ın size kazandırdığının çoğunu gizliyor.

12.3.3 Taramanın maliyeti ve o sayıların hangilerine güveniyoruz

Eğitim maliyeti, yeniden üretilebilir olan optimizasyon adımlarıyla ve yeniden üretilebilir olmayan saniyelerle ölçülüyor — ve bu koşu, ayrımın neden önemli olduğunun iyi bir örneği.

labels   steps   wall-clock   s/step
 1,000     640       525.5s    0.821   ← soğuk başlangıçtan sonraki ilk GPU koşusu
 2,000   1,260       387.0s    0.307
 5,000     471       147.5s    0.313
10,000     939       289.5s    0.308
20,000   1,875       581.5s    0.310
40,000   3,750     6,303.1s    1.681   ← makine koşunun ortasında yavaşladı

Ardışık dört koşunun hepsi, batch 32 ve max_length 128’de adım başına 0,307 ile 0,313 saniye arasında kalıyor. Bu gerçek bir ölçüm: veri kümesi boyutunda on kata (2.000’den 20.000 etikete) yayılan dört bağımsız koşu, birbirinden en fazla %2 sapıyor. Diğer ikisi öyle değil. 1.000 etiketli koşu bir defalık bir çekirdek derleme bedeli ödedi (Metal, Apple’ın GPU arayüzü); 40.000 etiketli koşu ise ilk epoch’u için 386 saniye, ikincisi için 386 ve üçüncüsü için 5.531 saniye harcadı — yapılan işte hiçbir değişiklik yokken 14× yavaşlama.

Dolayısıyla doğru ifade şu: adım başına 0,31 saniyede sekiz noktalı taramanın tamamı 9.395 adım, yani yaklaşık 49 dakika GPU zamanı; 40.000 etiketli model tek başına yaklaşık 19 dakika. Gerçekte gözlediğimiz 6.303 saniye, model hakkında değil o akşam dizüstünün hâli hakkında bir olgu ve onu bir eğitim maliyeti diye aktarmak, yeniden üretmeye çalışan her okuru yanıltırdı.

Çıkarım hızı çok daha tutarlı: her seferinde aynı 10.000 belge üzerinde yedi koşuda saniyede 499, 434, 462, 472, 466, 475 ve 510 belge. Saniyede 470 belge deyin — tek süreç, batchlenmiş, bir dizüstü GPU’sunda. Yalnızca 200 etiketli koşu, saniyede 17,5 belgeyle diğerlerinden ayrılıyor. O koşu bütün oturumun ilk çıkarım geçişiydi ve kendinden sonraki her şeyin adına çekirdek derlemesinin bedelini ödüyordu. Bir seri içindeki tek bir ölçüm 27× sapıyorsa, modelinizden önce değerlendirme düzeneğinizden şüphelenin.

Bunu, sekiz noktalı taramasının tamamı üç saniyelik dizüstü CPU zamanına sığan seyrek baseline ile karşılaştırın. En üst bütçede encoder’ın eğitimi 3.750 adım × 0,31 saniye, yani düzeltilmiş 1.162 saniyelik GPU zamanı tutuyor (kirlenmiş koşunun kaydettiği 6.303 değil). Bunun karşısında seyrek modelin 1,2 saniyelik CPU zamanı var. Encoder’ın eğitimi, 8,81 macro-F1 puanı uğruna kabaca 970× daha pahalı. Servis tarafında da baseline saniyede on binlerce belge işlerken encoder yaklaşık 470 belge işliyor. Bunun iyi bir ödünleşim (trade-off) olup olmadığı bir makine öğrenmesi sorusu değil; Bölüm 12.9, cevabı parayla vermeye çalıştığımız yer.

12.4 Doğruluğun ötesindeki metrikler

Şimdiye kadarki her sayı macro-F1’di. Hatırlatalım: bir sınıfın F1’i, o sınıftaki precision ile recall’un harmonik ortalamasıdır, \(F_1 = 2PR/(P+R)\) (bkz. Bölüm 4). Bu tercihin dayanağı Bölüm 4’ten devralınan bir sav: bu derlemde doğruluk işe yaramaz. Artık bunu iddia etmek yerine göstermenin vakti geldi.

Tek bir modeli, düzeltilmemiş tf-idf baseline’ını alın ve bir yorumu şikâyet ilan ettiği eşik dışında hiçbir şeyi oynatmayın. “Düzeltilmemiş”, sınıf ağırlığı kullanılmamış demek; bu kopya da cal temiz kalsın diye 32.000 belgelik fit dilimi üzerinde eğitildi. Yani yukarıdaki sınıf ağırlıklı 76,21’lik model bu değil. Bölüm 12.5 de aynı eğitilmiş modeli kullanıyor. Aşağıdaki tablo test üzerinde okunuyor ve seçim değil sergileme amaçlı: metriklerin aralık boyunca ne yaptığını göstermek için var, bir çalışma noktası seçmek için değil. Bölüm 12.5’te fiilen kullanılan çalışma noktası cal üzerinde seçildi ve 0,166 çıktı. Bu değer 0,15 ile 0,20 ızgara noktalarının arasında, buradaki en iyi satıra (0,15) yakın düşüyor. Pişmanlığı, test üzerinde okunan en iyi satırın 78,00’ine karşı 77,66, yani 0,34 macro-F1 puanı: işi düzgün yapmanın bedeli kabaca bu kadar.

   t      acc   bal-acc    prec     rec   compF1   macroF1     MCC
0.05    68.98     81.53   16.46   95.89    28.09     54.16   0.318
0.10    89.21     85.76   34.91   81.80    48.94     71.45   0.490
0.15    94.23     81.06   53.53   65.98    59.11     78.00   0.564
0.20    95.00     73.28   63.75   48.42    55.04     76.19   0.530
0.25    95.16     68.57   72.16   38.13    49.90     73.68   0.503
0.30    95.00     64.57   77.05   29.75    42.92     70.15   0.460
0.40    94.59     58.90   83.21   18.04    29.65     63.42   0.372
0.50    94.28     55.41   88.46   10.92    19.44     58.24   0.299
0.60    94.07     53.31   93.33    6.65    12.41     54.67   0.240
0.70    93.94     52.13   96.43    4.27     8.18     52.52   0.196
0.80    93.77     50.71  100.00    1.42     2.81     49.79   0.116
0.95    93.70     50.16  100.00    0.32     0.63     48.69   0.054

Doğruluk sütununu \(t \geq 0{,}2\) aralığında yukarıdan aşağı okuyun. 95,00’ten 93,70’e iniyor — 1,3 puan; arada da hiçbir zaman 1,5 puandan fazla açılmıyor. Aynı aralıkta, birinin harekete geçmesi gereken sınıftaki recall %48,42’den %0,32’ye düşüyor ve şikâyet-F1 55,04’ten 0,63’e iniyor. Sistem şikâyetlerin yarısını yakalamaktan hiçbirini yakalamamaya geçerken bir puan değişen bir metrik, sistemi ölçmüyordur.

Doğruluk işe yaramamakla kalmıyor, düpedüz yanıltıyor. Tablodaki en yüksek doğruluk \(t = 0{,}25\)’te 95,16. Tablodaki en iyi model ise \(t = 0{,}15\)’te; orada macro-F1 78,00 ve doğruluk 0,93 puan daha düşük. Maksimumu test kümesinden okuduğumuz için bu model, bölümün başındaki kurala (Bölüm 12.1) göre bir oracle’dır. Doğruluk üzerinden ayar yapmak yanlış çalışma noktasını seçiyor, üstelik bunu kendinden emin bir şekilde yapıyor.

Aşağıdaki widget tablonun tamamını çiziyor. Doğruluk, her seçimin arkasında gri çiziliyor; böylece hangi metriğe geçerseniz geçin, onu kıpırdamayan metrikle yan yana görüyorsunuz.

threshRows = [
  {t: 0.05, acc: 68.98, bal: 81.53, prec: 16.46, rec: 95.89, cf1: 28.09, mf1: 54.16, mcc: 0.318, tp: 606, fp: 3076, fn: 26},
  {t: 0.10, acc: 89.21, bal: 85.76, prec: 34.91, rec: 81.80, cf1: 48.94, mf1: 71.45, mcc: 0.490, tp: 517, fp: 964, fn: 115},
  {t: 0.15, acc: 94.23, bal: 81.06, prec: 53.53, rec: 65.98, cf1: 59.11, mf1: 78.00, mcc: 0.564, tp: 417, fp: 362, fn: 215},
  {t: 0.20, acc: 95.00, bal: 73.28, prec: 63.75, rec: 48.42, cf1: 55.04, mf1: 76.19, mcc: 0.530, tp: 306, fp: 174, fn: 326},
  {t: 0.25, acc: 95.16, bal: 68.57, prec: 72.16, rec: 38.13, cf1: 49.90, mf1: 73.68, mcc: 0.503, tp: 241, fp: 93, fn: 391},
  {t: 0.30, acc: 95.00, bal: 64.57, prec: 77.05, rec: 29.75, cf1: 42.92, mf1: 70.15, mcc: 0.460, tp: 188, fp: 56, fn: 444},
  {t: 0.35, acc: 94.79, bal: 61.36, prec: 80.66, rec: 23.10, cf1: 35.92, mf1: 66.60, mcc: 0.415, tp: 146, fp: 35, fn: 486},
  {t: 0.40, acc: 94.59, bal: 58.90, prec: 83.21, rec: 18.04, cf1: 29.65, mf1: 63.42, mcc: 0.372, tp: 114, fp: 23, fn: 518},
  {t: 0.45, acc: 94.36, bal: 56.71, prec: 82.69, rec: 13.61, cf1: 23.37, mf1: 60.22, mcc: 0.322, tp: 86, fp: 18, fn: 546},
  {t: 0.50, acc: 94.28, bal: 55.41, prec: 88.46, rec: 10.92, cf1: 19.44, mf1: 58.24, mcc: 0.299, tp: 69, fp: 9, fn: 563},
  {t: 0.55, acc: 94.18, bal: 54.32, prec: 91.67, rec: 8.70, cf1: 15.90, mf1: 56.44, mcc: 0.273, tp: 55, fp: 5, fn: 577},
  {t: 0.60, acc: 94.07, bal: 53.31, prec: 93.33, rec: 6.65, cf1: 12.41, mf1: 54.67, mcc: 0.240, tp: 42, fp: 3, fn: 590},
  {t: 0.65, acc: 93.99, bal: 52.53, prec: 96.97, rec: 5.06, cf1: 9.62, mf1: 53.26, mcc: 0.214, tp: 32, fp: 1, fn: 600},
  {t: 0.70, acc: 93.94, bal: 52.13, prec: 96.43, rec: 4.27, cf1: 8.18, mf1: 52.52, mcc: 0.196, tp: 27, fp: 1, fn: 605},
  {t: 0.75, acc: 93.85, bal: 51.42, prec: 94.74, rec: 2.85, cf1: 5.53, mf1: 51.18, mcc: 0.159, tp: 18, fp: 1, fn: 614},
  {t: 0.80, acc: 93.77, bal: 50.71, prec: 100.00, rec: 1.42, cf1: 2.81, mf1: 49.79, mcc: 0.116, tp: 9, fp: 0, fn: 623},
  {t: 0.85, acc: 93.77, bal: 50.71, prec: 100.00, rec: 1.42, cf1: 2.81, mf1: 49.79, mcc: 0.116, tp: 9, fp: 0, fn: 623},
  {t: 0.90, acc: 93.75, bal: 50.55, prec: 100.00, rec: 1.11, cf1: 2.19, mf1: 49.48, mcc: 0.102, tp: 7, fp: 0, fn: 625},
  {t: 0.95, acc: 93.70, bal: 50.16, prec: 100.00, rec: 0.32, cf1: 0.63, mf1: 48.69, mcc: 0.054, tp: 2, fp: 0, fn: 630}
]

viewof threshMetric = Inputs.radio(
  new Map([
    ["Şikâyetlerde recall — 632'nin kaçını bulduk?", "rec"],
    ["Şikâyetlerde precision — işaretlediklerimizin ne kadarı doğruydu?", "prec"],
    ["Şikâyet F1 — bu ikisinin harmonik ortalaması", "cf1"],
    ["Macro-F1 — bu bölümün en iyilediği metrik", "mf1"],
    ["Dengelenmiş doğruluk — sınıflar eşit ağırlıklı doğruluk", "bal"],
    ["Matthews korelasyonu × 100 — şans düzeltmeli özet", "mcc100"]
  ]),
  { value: "rec", label: "" }
)

threshLabels = ({
  rec: "şikâyet recall (%)", prec: "şikâyet precision (%)",
  cf1: "şikâyet F1", mf1: "macro-F1",
  bal: "dengelenmiş doğruluk (%)", mcc100: "MCC × 100"
})

threshPlot = {
  const pick = d => threshMetric === "mcc100" ? d.mcc * 100 : d[threshMetric];
  return Plot.plot({
    width: 700,
    height: 340,
    marginLeft: 56,
    marginBottom: 46,
    x: { label: "karar eşiği t — puan bunu aştığında yorumu işaretle", grid: true },
    y: { label: threshLabels[threshMetric], domain: [0, 100], grid: true },
    marks: [
      Plot.line(threshRows, { x: "t", y: "acc", stroke: "currentColor", strokeWidth: 2, strokeDasharray: "5 3" }),
      Plot.dot(threshRows, { x: "t", y: "acc", fill: "currentColor", r: 2.5,
        title: d => `t = ${d.t}\ndoğruluk: ${d.acc}%` }),
      Plot.text([threshRows[13]], { x: "t", y: "acc", text: ["doğruluk"],
        dy: -12, fill: "currentColor", fontWeight: 600 }),
      threshMetric === "mf1"
        ? Plot.ruleY([48.37], { stroke: "#B3453E", strokeDasharray: "3 3", strokeOpacity: 0.5 })
        : null,
      Plot.line(threshRows, { x: "t", y: pick, stroke: "#1F4E79", strokeWidth: 2.5 }),
      Plot.dot(threshRows, { x: "t", y: pick, fill: "#1F4E79", r: 3.5,
        title: d => `t = ${d.t}\n${threshLabels[threshMetric]}: ${pick(d).toFixed(2)}\n` +
                    `${d.tp} yakalandı, ${d.fp} yanlış alarm, ${d.fn} kaçtı` })
    ].filter(d => d)
  });
}

48,37’deki soluk kırmızı çizgi (yalnızca macro-F1 seçiliyken görünür), her zaman “memnun” diyen bir modelin macro-F1’i. Radyo düğmesini macro-F1’e getirin ve eşik yükseldikçe mavi çizginin ona doğru hızla düştüğünü izleyin: \(t = 0{,}8\)’i geçtikten sonra model fiilen sınıflandırıcı olmayı bırakmış durumda, doğruluk ise hâlâ 93,77.

Nedeni felsefe değil, aritmetik. Aşağıdaki dört satır hiçbir şey öğrenmeyen dört basit politika: her şeye “memnun” demek, taban oranda rastgele tahmin etmek, her şeye “şikâyet” demek ve yazı tura atmak.

call everything satisfied      acc 93.68   macroF1 48.37   bal-acc 50.00   MCC  0.000
guess at the base rate         acc 87.98   macroF1 49.76   bal-acc 49.76   MCC -0.005
call everything a complaint    acc  6.32   macroF1  5.94   bal-acc 50.00   MCC  0.000
coin flip                      acc 50.21   macroF1 38.57   bal-acc 51.44   MCC  0.014

Hiç öznitelik görmemiş bir model %93,68 doğruluk alıyor — yani taban oran (base rate). Bu bölümdeki her doğruluk rakamı o orana göre okunmak zorunda ve çoğu ona en fazla iki puan uzakta. Buna karşılık Matthews korelasyonu (MCC) o tablodaki beceri içermeyen her satıra sıfır ya da sıfıra 0,02’den yakın bir değer veriyor — iki sabit tahminciye tam 0,000 — bir özet istatistikten isteyeceğiniz şey de budur. Bölüm bu metriğe birden fazla kez yaslandığı için ne olduğunu burada söyleyelim: MCC, öngörülen etiket ile gerçek etiket iki 0/1 değişkeni olarak ele alındığında bu ikisi arasındaki Pearson korelasyonudur,

\[ \mathrm{MCC} = \frac{TP \cdot TN - FP \cdot FN} {\sqrt{(TP{+}FP)(TP{+}FN)(TN{+}FP)(TN{+}FN)}} \]

\(-1\) ile \(+1\) arasında değişir. Sıfırı doğru anlamak gerek, çünkü bu metriği seçmenin bütün sebebi o. Sabit bir tahminci için payda sıfırdır — her seferinde pozitif sınıfı söyleyen bir modelde \(TN = FN = 0\) — dolayısıyla MCC \(0/0\), yani tanımsızdır ve scikit-learn uzlaşım gereği 0 döndürür. Girdisinden bağımsız rastgele tahmin yürüten bir modelde ise MCC’nin beklenen değeri 0’dır ve gözlenen değer örneklem büyüklüğüne göre onun etrafında dalgalanır. Her iki durumda da cevap “aşağı yukarı hiçbir şey” — doğruluğun dengesiz veride söyleyemediği şey de budur.

O tabloya bilerek almadığımız bir metrik var ve ilk karşılaşacağınız metrik o. classification_report varsayılan olarak weighted-F1 basıyor: sınıf başına F1 puanlarının destek ağırlıklı ortalaması. Bu derlemde desteğin %93,68’i tek bir sınıfa ait, dolayısıyla her zaman “memnun” diyen modelin weighted-F1’i \(0{,}9368 \times 96{,}74 = 90{,}62\) — hiç özniteliği olmayan bir model için, bu bölümdeki her macro-F1’den yüksek. Weighted-F1, F1 kılığına girmiş doğruluktur. Micro-F1 ise — bütün sınıfların \(TP\), \(FP\) ve \(FN\) sayılarını toplayıp tek bir F1 hesaplamak — daha da kötü: her belgenin tam bir etiketi olduğunda doğrulukla birebir aynı sayıyı verir; burada 93,68. Dengesiz veride tek bir sayı raporlayacaksanız macro-F1 ya da MCC raporlayın; weighted-F1 raporluyorsanız yanına çoğunluk sınıfı oranını da koyun ki okur çıkarmayı kendi yapabilsin.

base rate (taban oran) — derlemin ne kadarının bir sınıfa ait olduğu. Aynı zamanda her zaman çoğunluk sınıfıyla cevap veren bir modelin doğruluğudur; bu da onu hesaplanacak ilk, raporlanan son sayı yapar. ↩︎

12.4.1 ROC ile precision-recall birbirinin yerine geçmez

İki eğri de aynı karışıklık matrisi (confusion matrix) sayılarından hesaplanıyor. Çelişmelerinin nedeni farklı şeylere bölmeleri: yanlış pozitif oranı 9.368 memnun yoruma bölüyor, precision ise kaç belge işaretlediyseniz ona bölüyor (Davis ve Goadrich 2006).

confusion matrix (karışıklık matrisi) — ikili bir sınıflandırıcının ürettiği dört sayı: doğru pozitifler, yanlış pozitifler, yanlış negatifler, doğru negatifler. Bu bölümdeki her metrik o dört sayıyla yapılan bir hesaptır; iki metriğin, hiçbiri yanlış olmadığı hâlde çelişebilmesinin nedeni budur. ↩︎

model                          AP      AUC   AP/base   bal-acc     MCC
tf-idf, uncorrected         60.30    93.24     9.54x     55.41   0.299
tf-idf, class-weighted      60.81    93.44     9.62x     84.34   0.545
tf-idf, SMOTE               58.05    92.81     9.19x     82.03   0.514
BERTurk n=200               12.78    70.12     2.02x     53.45   0.100
BERTurk n=500               26.98    83.00     4.27x     54.62   0.178
BERTurk n=1,000             45.72    82.76     7.23x     67.27   0.454
BERTurk n=2,000             62.34    92.51     9.86x     77.74   0.594
BERTurk n=5,000             66.37    93.98    10.50x     83.86   0.628

ROC (receiver operating characteristic) eğrisi, doğru pozitif oranını (TPR, yani recall) yanlış pozitif oranına (FPR) karşı çizer; altındaki alana AUC denir, bazen AUROC diye de yazılır. Precision-recall eğrisinin altındaki alan (PR-AUC) ise bu bölümde average precision (AP) ile hesaplanıyor. AUC’nin sade bir okuması var: rastgele seçilmiş bir şikâyetin, rastgele seçilmiş bir memnun yorumdan daha yüksek puan alma olasılığıdır; eşit puanlar yarım sayılır. Yalnızca puanların sırasına bakar, hiçbir eşiğe bakmaz.

93,24’lük bir AUC kulağa çözülmüş bir problem gibi geliyor. Aynı modelin aynı puanları için average precision ise 60,30. İkisi de doğru. AUC yüksek, çünkü model sıralamanın kolay çoğunluk kısmında çok iyi ve yanlış pozitif oranının paydasında, hataların içinde gizlenebileceği 9.368 belge var.

average precision (ortalama kesinlik) — precision-recall eğrisinin altında kalan alan, kısaca AP. AUC’nin aksine sınıf dengesiyle birlikte kıpırdar; dolayısıyla 60,30’luk bir AP, rastgele tahminin 6,32 alacağını bilene kadar hiçbir şey ifade etmez. ↩︎

Bunların farklı ölçümler olduğunun en açık kanıtı, BERTurk’ün 500 ile 1.000 etiket arasındaki davranışı: AUC düşüyor (83,00 → 82,76), average precision ise 18,7 puan yükseliyor (26,98 → 45,72) ve macro-F1 15,1 puan yükseliyor. AUC’yi izliyor olsaydınız, fazladan 500 etiketin modeli kötüleştirdiği sonucuna varırdınız.

Aşağıdaki widget, birbiriyle çelişen tam da bu iki görünümü çiziyor. Aynı modeller seçiliyken ROC uzayı ile PR uzayı arasında geçiş yapın ve eğrilerin sıralamasının değiştiğini izleyin.

curveRows = {
  // [model, curve space, x, y] — thinned from the full curves for the page
  const raw = [
    ["tfidf","roc",0.000,0.000], ["tfidf","roc",0.001,0.122], ["tfidf","roc",0.003,0.185], ["tfidf","roc",0.005,0.263],
    ["tfidf","roc",0.006,0.320], ["tfidf","roc",0.009,0.359], ["tfidf","roc",0.011,0.391], ["tfidf","roc",0.014,0.415],
    ["tfidf","roc",0.016,0.457], ["tfidf","roc",0.019,0.495], ["tfidf","roc",0.023,0.524], ["tfidf","roc",0.026,0.552],
    ["tfidf","roc",0.029,0.587], ["tfidf","roc",0.033,0.619], ["tfidf","roc",0.037,0.649], ["tfidf","roc",0.042,0.679],
    ["tfidf","roc",0.047,0.699], ["tfidf","roc",0.051,0.725], ["tfidf","roc",0.061,0.745], ["tfidf","roc",0.072,0.766],
    ["tfidf","roc",0.081,0.786], ["tfidf","roc",0.096,0.810], ["tfidf","roc",0.118,0.832], ["tfidf","roc",0.141,0.850],
    ["tfidf","roc",0.164,0.872], ["tfidf","roc",0.197,0.891], ["tfidf","roc",0.220,0.908], ["tfidf","roc",0.275,0.929],
    ["tfidf","roc",0.306,0.946], ["tfidf","roc",0.387,0.970], ["tfidf","roc",0.561,0.987], ["tfidf","roc",1.000,1.000],
    ["tfidf","pr",1.000,0.063], ["tfidf","pr",1.000,0.065], ["tfidf","pr",1.000,0.067], ["tfidf","pr",0.997,0.070],
    ["tfidf","pr",0.995,0.072], ["tfidf","pr",0.995,0.075], ["tfidf","pr",0.994,0.078], ["tfidf","pr",0.992,0.081],
    ["tfidf","pr",0.992,0.084], ["tfidf","pr",0.991,0.088], ["tfidf","pr",0.991,0.092], ["tfidf","pr",0.991,0.097],
    ["tfidf","pr",0.991,0.102], ["tfidf","pr",0.986,0.107], ["tfidf","pr",0.984,0.112], ["tfidf","pr",0.981,0.120],
    ["tfidf","pr",0.978,0.127], ["tfidf","pr",0.975,0.136], ["tfidf","pr",0.968,0.145], ["tfidf","pr",0.964,0.155],
    ["tfidf","pr",0.954,0.169], ["tfidf","pr",0.940,0.182], ["tfidf","pr",0.922,0.200], ["tfidf","pr",0.903,0.218],
    ["tfidf","pr",0.883,0.246], ["tfidf","pr",0.861,0.277], ["tfidf","pr",0.835,0.317], ["tfidf","pr",0.797,0.386],
    ["tfidf","pr",0.744,0.468], ["tfidf","pr",0.590,0.571], ["tfidf","pr",0.394,0.707], ["tfidf","pr",0.000,1.000],
    ["b500","roc",0.000,0.000], ["b500","roc",0.012,0.122], ["b500","roc",0.026,0.233], ["b500","roc",0.050,0.342],
    ["b500","roc",0.072,0.427], ["b500","roc",0.100,0.513], ["b500","roc",0.129,0.570], ["b500","roc",0.154,0.623],
    ["b500","roc",0.189,0.682], ["b500","roc",0.210,0.720], ["b500","roc",0.244,0.747], ["b500","roc",0.268,0.769],
    ["b500","roc",0.295,0.804], ["b500","roc",0.319,0.826], ["b500","roc",0.340,0.847], ["b500","roc",0.368,0.854],
    ["b500","roc",0.391,0.869], ["b500","roc",0.420,0.883], ["b500","roc",0.445,0.899], ["b500","roc",0.470,0.910],
    ["b500","roc",0.501,0.921], ["b500","roc",0.530,0.932], ["b500","roc",0.565,0.943], ["b500","roc",0.602,0.956],
    ["b500","roc",0.648,0.965], ["b500","roc",0.693,0.972], ["b500","roc",0.746,0.978], ["b500","roc",0.812,0.986],
    ["b500","roc",0.865,0.994], ["b500","roc",0.929,0.997], ["b500","roc",0.964,0.997], ["b500","roc",1.000,1.000],
    ["b500","pr",1.000,0.063], ["b500","pr",0.997,0.065], ["b500","pr",0.995,0.069], ["b500","pr",0.986,0.077],
    ["b500","pr",0.975,0.084], ["b500","pr",0.960,0.093], ["b500","pr",0.945,0.101], ["b500","pr",0.929,0.107],
    ["b500","pr",0.911,0.114], ["b500","pr",0.899,0.121], ["b500","pr",0.877,0.128], ["b500","pr",0.861,0.133],
    ["b500","pr",0.850,0.142], ["b500","pr",0.828,0.148], ["b500","pr",0.807,0.155], ["b500","pr",0.774,0.161],
    ["b500","pr",0.753,0.169], ["b500","pr",0.731,0.179], ["b500","pr",0.717,0.189], ["b500","pr",0.687,0.196],
    ["b500","pr",0.653,0.206], ["b500","pr",0.622,0.215], ["b500","pr",0.581,0.228], ["b500","pr",0.533,0.235],
    ["b500","pr",0.506,0.260], ["b500","pr",0.464,0.276], ["b500","pr",0.413,0.292], ["b500","pr",0.351,0.316],
    ["b500","pr",0.280,0.328], ["b500","pr",0.214,0.385], ["b500","pr",0.125,0.418], ["b500","pr",0.000,1.000],
    ["b1000","roc",0.000,0.000], ["b1000","roc",0.005,0.174], ["b1000","roc",0.010,0.299], ["b1000","roc",0.021,0.427],
    ["b1000","roc",0.033,0.519], ["b1000","roc",0.058,0.597], ["b1000","roc",0.083,0.639], ["b1000","roc",0.110,0.669],
    ["b1000","roc",0.138,0.682], ["b1000","roc",0.157,0.691], ["b1000","roc",0.180,0.699], ["b1000","roc",0.198,0.714],
    ["b1000","roc",0.223,0.722], ["b1000","roc",0.245,0.728], ["b1000","roc",0.267,0.737], ["b1000","roc",0.294,0.745],
    ["b1000","roc",0.317,0.747], ["b1000","roc",0.341,0.752], ["b1000","roc",0.362,0.755], ["b1000","roc",0.382,0.763],
    ["b1000","roc",0.403,0.774], ["b1000","roc",0.422,0.785], ["b1000","roc",0.448,0.815], ["b1000","roc",0.467,0.837],
    ["b1000","roc",0.487,0.858], ["b1000","roc",0.505,0.878], ["b1000","roc",0.529,0.889], ["b1000","roc",0.569,0.903],
    ["b1000","roc",0.627,0.921], ["b1000","roc",0.732,0.960], ["b1000","roc",0.892,0.986], ["b1000","roc",1.000,1.000],
    ["b1000","pr",1.000,0.063], ["b1000","pr",0.976,0.073], ["b1000","pr",0.927,0.090], ["b1000","pr",0.891,0.100],
    ["b1000","pr",0.872,0.105], ["b1000","pr",0.848,0.108], ["b1000","pr",0.824,0.109], ["b1000","pr",0.802,0.110],
    ["b1000","pr",0.783,0.112], ["b1000","pr",0.771,0.115], ["b1000","pr",0.761,0.120], ["b1000","pr",0.753,0.126],
    ["b1000","pr",0.748,0.136], ["b1000","pr",0.744,0.147], ["b1000","pr",0.736,0.158], ["b1000","pr",0.725,0.174],
    ["b1000","pr",0.720,0.189], ["b1000","pr",0.699,0.205], ["b1000","pr",0.695,0.224], ["b1000","pr",0.687,0.242],
    ["b1000","pr",0.677,0.268], ["b1000","pr",0.665,0.293], ["b1000","pr",0.647,0.324], ["b1000","pr",0.631,0.354],
    ["b1000","pr",0.606,0.395], ["b1000","pr",0.585,0.442], ["b1000","pr",0.547,0.489], ["b1000","pr",0.479,0.543],
    ["b1000","pr",0.408,0.600], ["b1000","pr",0.288,0.650], ["b1000","pr",0.174,0.728], ["b1000","pr",0.000,1.000],
    ["b5000","roc",0.000,0.000], ["b5000","roc",0.004,0.274], ["b5000","roc",0.007,0.384], ["b5000","roc",0.012,0.495],
    ["b5000","roc",0.017,0.581], ["b5000","roc",0.026,0.660], ["b5000","roc",0.034,0.718], ["b5000","roc",0.056,0.766],
    ["b5000","roc",0.076,0.820], ["b5000","roc",0.122,0.866], ["b5000","roc",0.192,0.910], ["b5000","roc",0.253,0.937],
    ["b5000","roc",0.331,0.956], ["b5000","roc",0.388,0.965], ["b5000","roc",0.431,0.970], ["b5000","roc",0.478,0.972],
    ["b5000","roc",0.518,0.973], ["b5000","roc",0.551,0.978], ["b5000","roc",0.584,0.981], ["b5000","roc",0.617,0.983],
    ["b5000","roc",0.646,0.984], ["b5000","roc",0.679,0.984], ["b5000","roc",0.718,0.986], ["b5000","roc",0.743,0.987],
    ["b5000","roc",0.773,0.991], ["b5000","roc",0.802,0.995], ["b5000","roc",0.827,0.995], ["b5000","roc",0.851,0.997],
    ["b5000","roc",0.881,0.998], ["b5000","roc",0.916,1.000], ["b5000","roc",0.942,1.000], ["b5000","roc",1.000,1.000],
    ["b5000","pr",1.000,0.063], ["b5000","pr",1.000,0.065], ["b5000","pr",1.000,0.067], ["b5000","pr",0.998,0.070],
    ["b5000","pr",0.997,0.072], ["b5000","pr",0.995,0.076], ["b5000","pr",0.992,0.078], ["b5000","pr",0.991,0.082],
    ["b5000","pr",0.986,0.085], ["b5000","pr",0.984,0.089], ["b5000","pr",0.984,0.094], ["b5000","pr",0.981,0.098],
    ["b5000","pr",0.981,0.104], ["b5000","pr",0.976,0.110], ["b5000","pr",0.972,0.115], ["b5000","pr",0.972,0.124],
    ["b5000","pr",0.970,0.132], ["b5000","pr",0.965,0.142], ["b5000","pr",0.960,0.151], ["b5000","pr",0.956,0.163],
    ["b5000","pr",0.951,0.178], ["b5000","pr",0.940,0.193], ["b5000","pr",0.927,0.213], ["b5000","pr",0.915,0.235],
    ["b5000","pr",0.900,0.268], ["b5000","pr",0.880,0.302], ["b5000","pr",0.853,0.346], ["b5000","pr",0.818,0.421],
    ["b5000","pr",0.758,0.507], ["b5000","pr",0.644,0.663], ["b5000","pr",0.413,0.789], ["b5000","pr",0.000,1.000]
  ];
  return raw.map(([model, space, x, y]) => ({model, space, x, y}));
}

viewof rocSpace = Inputs.radio(
  new Map([
    ["ROC uzayı — recall'a karşı yanlış pozitif oranı", "roc"],
    ["Precision-recall uzayı — recall'a karşı precision", "pr"]
  ]),
  { value: "roc", label: "" }
)

rocNames = ({
  tfidf: "tf-idf + LR, düzeltilmemiş, 32.000 etiket", b500: "BERTurk, 500 etiket",
  b1000: "BERTurk, 1.000 etiket", b5000: "BERTurk, 5.000 etiket"
})

rocPlot = {
  const data = curveRows.filter(d => d.space === rocSpace);
  const isRoc = rocSpace === "roc";
  return Plot.plot({
    width: 640,
    height: 440,
    marginLeft: 60,
    marginBottom: 48,
    x: { label: isRoc ? "yanlış pozitif oranı — 9.368 memnun yorumun işaretlenen payı"
                      : "recall — 632 şikâyetin yakalanan payı",
         domain: [0, 1], grid: true },
    y: { label: isRoc ? "doğru pozitif oranı — 632 şikâyetin yakalanan payı"
                      : "precision — işaretlenenlerin doğru çıkan payı",
         domain: [0, 1], grid: true },
    color: { legend: true, domain: ["tfidf", "b500", "b1000", "b5000"],
             range: ["#1F4E79", "#C08A3E", "#B3453E", "#0E7C7B"],
             tickFormat: k => rocNames[k] },
    marks: [
      isRoc
        ? Plot.line([[0, 0], [1, 1]], { stroke: "currentColor", strokeDasharray: "5 4" })
        : Plot.ruleY([0.0632], { stroke: "currentColor", strokeDasharray: "5 4" }),
      Plot.line(data, { x: "x", y: "y", stroke: "model", strokeWidth: 2 })
    ]
  });
}

Kesik çizgi her uzayda farklı bir şey demek. ROC uzayında yazı tura atmanın çizdiği köşegen. PR uzayında ise 0,0632’deki yatay çizgi — yani taban oran, belgeleri rastgele işaretlediğinizde precision’ın eşit olduğu değer. ROC grafiğinin ne kadarının kendi baseline’ının çok üstünde durduğuna, PR grafiğinin ise ne kadar azının durduğuna dikkat edin. Aynı modeller, aynı puanlar.

AP/base sütunu, average precision’ı okumanın doğru yolu: %6,32’lik bir taban orana göre 60,30, rastgele tahminden 9,54× daha iyi demektir. Bu, “60”ın tek başına aktaramadığı gerçek bir başarıdır.

12.5 Sınıf dengesizliği

Derlemin %93,68’i memnun. Bu sınıf dengesizliği (class imbalance) durumuna verilen standart cevaplar şunlar: hiçbir şey yapmamak, sınıfları ağırlıklandırmak, azınlığı fazla örneklemek, çoğunluğu eksik örneklemek ya da SMOTE ile yeni azınlık noktaları sentezlemek (Chawla vd. 2002). SMOTE her yapay noktayı, bir azınlık örneği ile ona en yakın azınlık komşularından biri arasındaki doğru parçası üzerinde üretir. Bir de genellikle en sona yazılan ve bir kolaycılık muamelesi gören altıncı bir seçenek var — kazanan o.

class imbalance (sınıf dengesizliği) — tek bir etiket derleme hâkim olur; böylece doğruluk bilgi taşımayı bırakır, kayıp fonksiyonu da sistemi asıl kurma nedeniniz olan sınıfı umursamaz hâle gelir. Verinin bir özelliğidir, içindeki bir bozukluk değil. ↩︎

Aşağıdaki her şey 32.000 belgelik fit dilimi üzerinde eğitildi, her eşik ayrılmış cal dilimi üzerinde seçildi ve test üzerinde puanlandı.

treatment                     acc   macroF1   compF1   comp-P   comp-R      AP     AUC
no correction, t=0.5        94.28     58.24    19.44     88.5     10.9   60.30   93.24
threshold moved to 0.166    94.64     77.66    58.19     57.4     59.0   60.30   93.24
class_weight=balanced       92.63     76.09    56.21     45.0     74.8   60.81   93.44
random oversampling         93.63     77.63    58.72     49.7     71.7   61.46   93.45
random undersampling        81.08     62.98    37.10     23.5     88.3   52.49   92.15
SMOTE                       92.32     74.72    53.62     43.4     70.3   58.05   92.81

Dört yöntem sıralamayı değiştiriyor. Biri kararı değiştiriyor.

Eksen 0’dan değil 45’ten başlıyor, çünkü hiç özniteliği olmayan bir model 48,37 alıyor ve ilginç olan her şey onun üstünde oluyor. AP sütunu kontrol değişkeni: average precision yalnızca sıralamaya bağlıdır, dolayısıyla iki farklı eşikte okunan aynı eğitilmiş model aynı AP’yi göstermek zorundadır — tablonun 1. ve 2. satırları da dört anlamlı basamağa kadar bunu gösteriyor.

Bu alt bölümün tamamı ikinci satırda. Birinci satırdakiyle aynı model — yeniden eğitilmedi, yeniden ağırlıklandırılmadı, yeniden örneklenmedi, birebir aynı kestirilmiş katsayılar — 58,24’ten 77,66 macro-F1’e çıkıyor, çünkü bir yorumu \(P(\text{şikâyet})\) 0,5’i değil 0,166’yı geçtiğinde şikâyet olarak işaretledik.

Modelde hiçbir şeyin değişmediğinin kanıtı son iki sütunda. Birinci ve ikinci satırda average precision ile AUC dört anlamlı basamağa kadar özdeş, çünkü ikisi de sıralamadan hesaplanıyor ve bir eşiği oynatmak hiçbir şeyin sırasını değiştiremez. Yeniden eğitim gerektiren dört yöntem — sınıf ağırlıkları, aşırı örnekleme, eksik örnekleme, SMOTE — bir kararı düzeltmek için bir sıralamayı değiştirme girişimi. Eşiği oynatmak ise kararı doğrudan düzeltiyor.

Tablonun adil davranmadığı bir nokta var; ana sonucu okurken bunu aklınızda tutun. Altı satırın yalnızca birine kendi eşiğini seçme izni verildi; diğer beşi 0,5’te okundu. Bu, ayarlanmış bir kolu ayarlanmamış kollarla yarıştırmaktır. Bölümün kendi argümanı, aksi hâlde sonucun nasıl çıkacağını söylüyor: average precision yalnızca sıralamaya bağlıdır ve bu ölçütte aşırı örnekleme 61,46, sınıf ağırlıkları 60,81, düzeltmesiz model 60,30 alıyor. Yani her kola cal üzerinde kendi eşiği verilseydi aşırı örnekleme büyük ihtimalle kıl payı önde biterdi, arkada değil. O üç satırı çalıştırmadık. Bu alt bölümü sıralama hakkında değil, fiyat hakkında bir sonuç olarak okuyun: tek bir eşiği oynatmak, en iyi yeniden örnekleme yönteminin ulaştığı çalışma noktasına sıfır eğitim maliyetiyle ulaşıyor — onu yenmiyor.

Buna karşılık, yeniden eğitim yöntemleri istedikleri bedel düşünüldüğünde pahalı görünüyor:

• Sınıf ağırlıkları 76,09’a ulaşıyor: maliyetsiz seçeneğin 1,57 puan altında, üstelik bir yeniden eğitim maliyetiyle.
• Rastgele aşırı örnekleme 77,63’e ulaşıyor; eşiği oynatmanın yalnızca 0,03 puan gerisinde, ama 32.000 yerine 59.954 satır üzerinde — beraberlik gibi görünen bir sonuç için neredeyse iki kat eğitim süresi. O farkı resmî olarak test etmedik; 0,03 puanlık bir fark, 632 şikâyet içeren bir test kümesinin ayırt edebileceğinin çok altında. Tablo bize yalnızca “ikisi ayırt edilemiyor” deme hakkı veriyor.
• Rastgele eksik örnekleme bir felaket: 62,98. Eşitlik sağlamak için 32.000 belgenin 27.954’ünü çöpe attı ve attığı çoğunluk sınıfı, şikâyet olmayan bir yorumun neye benzediğine dair bilginin çoğunu taşıyordu. Precision %23,5’e kadar düşüyor.
• SMOTE 74,72’ye ulaşıyor; hiçbir şey yapmayıp eşiği oynatmaktan da, sınıf ağırlıklarından da kötü.

SMOTE’un buradaki kötü performansı makaleyi çürütmüyor ve bölüm çürüttüğü numarasını yapmamalı. Chawla ve arkadaşları düşük boyutlu, yoğun (dense), sayısal dokuz veri kümesini değerlendirdi — Pima, Phoneme, Adult, Satimage vb. — ve metin verisine uygulanmasını açıkça gelecek çalışma olarak listeleyip “bir öznitelik seçme algoritmasıyla birlikte uygulanması gerekirdi” dedi (Chawla vd. 2002). İki seyrek tf-idf satırı arasında ara değer bulmak, kimsenin yazamayacağı bir belgeye karşılık gelen bir nokta üretiyor. (Buradaki boyut sayısı başka yerlerde geçen 101.659 değil, 83.281; çünkü bu alt bölüm 40.000 belgenin tamamı yerine 32.000 belgelik fit dilimi üzerinde eğitim yapıyor.) Bunu, yazarlar burada işe yarayacağını iddia ettikleri için değil, uygulamacıların başvurduğu yöntem olduğu için ölçtük.

Bu sonuç derlemimize özgü bir tuhaflık değil. Van den Goorbergh ve arkadaşları aynı şeyi klinik risk modellerinde buldu ve bizim cesaret edebileceğimizden daha sert bir dille ifade etti: dengesizlik düzeltmeleri ayırt etme gücünde hiçbir şey kazandırmıyor ve başka yerlerde gerçek hasar veriyor (van den Goorbergh vd. 2022). Bölüm 12.6 hasarı ölçüyor.

Bu konu açıldığında herkesin atıf yaptığı Elkan makalesi de aynı yönde bir sav öne sürüyor. Tavsiyesini doğru aktarmakta fayda var, çünkü rutin olarak tersine çevriliyor. Elkan’ın tavsiyesi şu: sınıflandırıcıyı eğitim kümesini olduğu gibi kullanarak öğrenmek, sonra en iyi kararları açıkça hesaplamak (Elkan 2001). Bu, yeniden örnekleme lehine değil, aleyhine bir sav.

12.6 O sayı bir olasılık mı?

Eşiği oynatmak işe yarıyor. Ama bu, bir önceki kısmın sessizce atladığı bir soruyu doğuruyor: 0,166 sayısı, ayrılmış veri üzerinde yapılan bir taramadan geldi. Bunun yerine bir eşiği türetmek isteseydiniz — diyelim ki bir maliyet matrisinden — modelin çıktısının bir anlam taşıması gerekirdi. Öyleyse: sınıflandırıcı bir yorumun 0,834 olasılıkla memnun olduğunu söylediğinde, bu bir olasılık mı?

Buradaki her şey 8.000 belgelik cal dilimi üzerinde ayarlandı — bu kısımdaki hiçbir model onun üzerinde eğitilmedi — ve test üzerinde puanlandı. Bütün mesele o ayrım; aşağıdaki BERTurk satırının, öğrenme eğrisini üreten 40.000 belgelik train yerine 32.000 belgelik fit dilimi üzerinde eğitilmiş bir model olmasının nedeni de bu. Sınıflandırıcının zaten iyi öğrendiği belgeler üzerinde ayarlanan bir kalibratör, sınıflandırıcı kalibre değilken kalibre olduğunu raporlar.

Tablodaki dört istatistiğin her biri birer cümleyi hak ediyor. Hepsi, memnun için öngörülen olasılığı gerçekte olanla karşılaştırır. ECE (beklenen kalibrasyon hatası), test belgelerini öngörülen olasılığa göre eşit genişlikte on beş kutucuğa ayırır; her kutucuğun ortalama tahmini ile o kutucuktaki belgelerin gerçekten memnun olan payı arasındaki farkı alır ve bu farkların kutucuk büyüklüğüyle ağırlıklı ortalamasını hesaplar; tabloda yüzde puan olarak basılıyor. MCE (en büyük kalibrasyon hatası), kutucuk ne kadar küçük olursa olsun bu farkların en büyüğüdür. Brier skoru, öngörülen olasılık ile 0/1 sonuç arasındaki farkın karesinin ortalamasıdır; log loss ise modelin gerçekte gerçekleşen etikete verdiği olasılığın \(-\log\)’unun ortalamasıdır. Dördü için de düşük olan iyidir; son ikisi kutucuk gerektirmez.

Üç onarım yönteminin üçü de cal üzerinde ayarlanır. Modelin logit’ine \(z\), lojistik sigmoide \(\sigma\) dersek: sıcaklık ölçeklemesi (temperature scaling) tek bir \(T\) sayısı öğrenir ve \(\sigma(z/T)\) verir; Platt ölçeklemesi bir eğim ve bir sabit terim (intercept) öğrenir ve \(\sigma(az + b)\) verir; izotonik regresyon ise hiç azalmayan herhangi bir eşleme öğrenir.

model / method                       ECE    MCE    Brier   logloss   mean p
tf-idf, no correction — raw         3.96  39.32   0.0421    0.1514    0.940
  — temperature                     3.20  39.36   0.0426    0.1489    0.952
  — Platt                           0.94  16.58   0.0368    0.1318    0.935
  — isotonic                        0.69  32.96   0.0367    0.1309    0.935
  — isotonic fitted on TRAIN        2.39  24.66   0.0387    0.1487    0.942

tf-idf, class-weighted — raw       14.18  35.93   0.0675    0.2448    0.795
  — temperature                     7.80  43.29   0.0568    0.1974    0.859
  — Platt                           0.93  15.28   0.0364    0.1300    0.935
  — isotonic                        0.88  72.20   0.0364    0.1295    0.935

BERTurk, class-weighted — raw       2.53  49.84   0.0318    0.1442    0.933
  — temperature                     2.58  50.02   0.0303    0.1224    0.913
  — Platt                           1.25  31.65   0.0275    0.1062    0.936
  — isotonic                        0.56  45.84   0.0265    0.0984    0.936

Bu tablodaki her ECE bir gürültü tabanı taşıyor ve farkların birkaçı onun altında. ECE, her kutucukta gözlenen bir frekansla ortalama bir tahmini karşılaştırıyor; gözlenen frekans ise bir binom çekilişi: kalibrasyon kusursuz olsa bile ikisi şansa bağlı olarak ayrışır. Bizim kutucuk doluluklarımızda tek başına bu gürültü, beklenen ECE değerini yaklaşık yarım puan yapıyor. Yani Platt’ın 0,94’üne karşı izotonik regresyonun 0,69’u — 0,25’lik bir fark — iki yöntem arasındaki bir farkın ölçümü değil; BERTurk’ün 0,56’sı da kusursuz kalibrasyondan ayırt edilebilir değil. Gürültü tabanının üstünde kalan şey ham ile kalibre arasındaki fark (3,96 → 0,9) ve sınıf ağırlıklandırma cezası (3,96 → 14,18); ikisi de gürültü tabanının birkaç katı yukarıda. ECE’yi yansız kestirmek kendi küçük literatürü olan bir konu (Kumar vd. 2019; Roelofs vd. 2022); pratik kural, bir puandan küçük hiçbir kalibrasyon farkına bootstrap yapmadan güvenmemek.

Bu sayılar bir resmin özeti ve resim özetten daha bilgilendirici. Aşağıdaki her nokta on beş kutucuktan biri: yatay eksende kutucuğun ortalama öngörülen olasılığında, dikey eksende o kutucukta gerçekten memnun çıkan yorumların payında duruyor. Kusursuz kalibrasyon köşegendir. Nokta alanı kutucuktaki belge sayısını gösteriyor, çünkü üç belge tutan bir kutucukla 7.317 belge tutan bir kutucuk aynı derecede önemli görünmemeli.

relRows = {
  // [model, calibration method, mean predicted probability in bin,
  //  observed frequency of the satisfied class, documents in bin]
  const raw = [
    ["plain","raw",0.0447,0.0000,3], ["plain","raw",0.0864,0.0000,5], ["plain","raw",0.1473,0.0000,1],
    ["plain","raw",0.2326,0.0769,13], ["plain","raw",0.2951,0.0000,10], ["plain","raw",0.3722,0.1538,13],
    ["plain","raw",0.4298,0.2222,18], ["plain","raw",0.5023,0.2258,31], ["plain","raw",0.5692,0.2093,43],
    ["plain","raw",0.6352,0.2419,62], ["plain","raw",0.7024,0.4074,108], ["plain","raw",0.7732,0.5318,173],
    ["plain","raw",0.8387,0.6644,444], ["plain","raw",0.9082,0.9312,1759], ["plain","raw",0.9727,0.9923,7317],
    ["plain","temp",0.0443,0.0000,6], ["plain","temp",0.0938,0.0000,3], ["plain","temp",0.1865,0.2000,5],
    ["plain","temp",0.2315,0.0000,12], ["plain","temp",0.2913,0.0000,7], ["plain","temp",0.3667,0.2000,15],
    ["plain","temp",0.4337,0.1667,18], ["plain","temp",0.5056,0.2593,27], ["plain","temp",0.5726,0.2051,39],
    ["plain","temp",0.6367,0.2653,49], ["plain","temp",0.7022,0.3086,81], ["plain","temp",0.7680,0.5276,127],
    ["plain","temp",0.8390,0.5750,320], ["plain","temp",0.9093,0.8784,1135], ["plain","temp",0.9776,0.9882,8156],
    ["plain","platt",0.0269,0.0984,61], ["plain","platt",0.1025,0.2683,41], ["plain","platt",0.1661,0.2105,38],
    ["plain","platt",0.2322,0.2439,41], ["plain","platt",0.3034,0.3023,43], ["plain","platt",0.3688,0.3571,42],
    ["plain","platt",0.4285,0.4600,50], ["plain","platt",0.5047,0.5098,51], ["plain","platt",0.5703,0.5806,62],
    ["plain","platt",0.6338,0.5545,101], ["plain","platt",0.7033,0.5946,111], ["plain","platt",0.7656,0.6789,190],
    ["plain","platt",0.8388,0.8457,337], ["plain","platt",0.9061,0.9261,852], ["plain","platt",0.9866,0.9893,7980],
    ["plain","iso",0.0892,0.0323,31], ["plain","iso",0.1562,0.2329,73], ["plain","iso",0.2561,0.2695,141],
    ["plain","iso",0.3296,0.0000,1], ["plain","iso",0.3415,0.4308,65], ["plain","iso",0.4074,0.4138,29],
    ["plain","iso",0.4906,0.6197,71], ["plain","iso",0.6315,0.5768,241], ["plain","iso",0.7186,0.6600,150],
    ["plain","iso",0.7568,0.7547,53], ["plain","iso",0.8515,0.8487,476], ["plain","iso",0.9112,0.9442,573],
    ["plain","iso",0.9885,0.9888,8096], ["plain","leak",0.0378,0.1818,143], ["plain","leak",0.0817,0.2353,17],
    ["plain","leak",0.1542,0.3386,127], ["plain","leak",0.2234,0.4545,22], ["plain","leak",0.2952,0.4918,61],
    ["plain","leak",0.3815,0.5588,136], ["plain","leak",0.4200,0.6667,9], ["plain","leak",0.4800,0.6111,18],
    ["plain","leak",0.5866,0.5902,61], ["plain","leak",0.6180,0.6575,73], ["plain","leak",0.7546,0.6000,70],
    ["plain","leak",0.8202,0.7264,106], ["plain","leak",0.9000,0.8484,343], ["plain","leak",0.9953,0.9834,8814],
    ["weighted","raw",0.0347,0.1389,72], ["weighted","raw",0.1005,0.2653,98], ["weighted","raw",0.1649,0.3107,103],
    ["weighted","raw",0.2351,0.4211,114], ["weighted","raw",0.2988,0.5641,156], ["weighted","raw",0.3674,0.6514,175],
    ["weighted","raw",0.4362,0.7535,215], ["weighted","raw",0.5028,0.8271,266], ["weighted","raw",0.5693,0.9286,392],
    ["weighted","raw",0.6347,0.9570,512], ["weighted","raw",0.7033,0.9475,648], ["weighted","raw",0.7694,0.9747,868],
    ["weighted","raw",0.8357,0.9903,1243], ["weighted","raw",0.9030,0.9955,1994], ["weighted","raw",0.9684,0.9981,3144],
    ["weighted","temp",0.0216,0.2646,291], ["weighted","temp",0.1013,0.4615,143], ["weighted","temp",0.1657,0.5487,113],
    ["weighted","temp",0.2337,0.6667,108], ["weighted","temp",0.2972,0.6633,98], ["weighted","temp",0.3667,0.7563,119],
    ["weighted","temp",0.4334,0.7983,119], ["weighted","temp",0.5023,0.8080,125], ["weighted","temp",0.5670,0.9018,163],
    ["weighted","temp",0.6340,0.9126,206], ["weighted","temp",0.7018,0.9643,280], ["weighted","temp",0.7704,0.9474,323],
    ["weighted","temp",0.8362,0.9470,453], ["weighted","temp",0.9039,0.9681,877], ["weighted","temp",0.9870,0.9953,6582],
    ["weighted","platt",0.0281,0.0909,55], ["weighted","platt",0.1045,0.2093,43], ["weighted","platt",0.1615,0.3143,35],
    ["weighted","platt",0.2340,0.2500,52], ["weighted","platt",0.2976,0.2564,39], ["weighted","platt",0.3674,0.3721,43],
    ["weighted","platt",0.4388,0.4400,50], ["weighted","platt",0.5015,0.4364,55], ["weighted","platt",0.5678,0.5000,86],
    ["weighted","platt",0.6336,0.5745,94], ["weighted","platt",0.7026,0.6818,132], ["weighted","platt",0.7708,0.7072,181],
    ["weighted","platt",0.8372,0.8199,311], ["weighted","platt",0.9056,0.9413,801], ["weighted","platt",0.9872,0.9889,8023],
    ["weighted","iso",0.0702,0.0345,29], ["weighted","iso",0.1406,0.1951,41], ["weighted","iso",0.2215,0.2850,200],
    ["weighted","iso",0.2780,1.0000,1], ["weighted","iso",0.3349,0.4250,40], ["weighted","iso",0.4622,0.0000,1],
    ["weighted","iso",0.4706,0.4222,45], ["weighted","iso",0.5909,0.5161,93], ["weighted","iso",0.6570,0.5674,141],
    ["weighted","iso",0.6934,0.6837,196], ["weighted","iso",0.7660,0.7853,191], ["weighted","iso",0.8598,0.8161,174],
    ["weighted","iso",0.9043,0.9410,814], ["weighted","iso",0.9893,0.9889,8034],
    ["bert","raw",0.0056,0.2210,525], ["bert","raw",0.1029,0.5500,20], ["bert","raw",0.1690,0.5833,12],
    ["bert","raw",0.2289,0.7273,11], ["bert","raw",0.2826,0.4286,7], ["bert","raw",0.3778,0.8462,13],
    ["bert","raw",0.4267,0.5000,10], ["bert","raw",0.5041,0.8462,13], ["bert","raw",0.5681,0.6429,14],
    ["bert","raw",0.6310,0.5833,12], ["bert","raw",0.7014,0.6842,19], ["bert","raw",0.7704,0.6000,25],
    ["bert","raw",0.8351,0.8077,52], ["bert","raw",0.9056,0.7759,116], ["bert","raw",0.9950,0.9857,9151],
    ["bert","temp",0.0194,0.1917,480], ["bert","temp",0.0944,0.5946,37], ["bert","temp",0.1588,0.3333,18],
    ["bert","temp",0.2310,0.7059,17], ["bert","temp",0.2977,0.6000,15], ["bert","temp",0.3549,0.5556,9],
    ["bert","temp",0.4320,0.6500,20], ["bert","temp",0.5041,0.7895,19], ["bert","temp",0.5676,0.6000,20],
    ["bert","temp",0.6356,0.6957,23], ["bert","temp",0.7035,0.6250,40], ["bert","temp",0.7679,0.8507,67],
    ["bert","temp",0.8399,0.7973,148], ["bert","temp",0.9065,0.9020,490], ["bert","temp",0.9787,0.9915,8597],
    ["bert","platt",0.1149,0.0485,227], ["bert","platt",0.1576,0.2281,171], ["bert","platt",0.2254,0.4524,42],
    ["bert","platt",0.2930,0.5750,40], ["bert","platt",0.3636,0.5263,19], ["bert","platt",0.4335,0.7500,16],
    ["bert","platt",0.4935,0.2667,15], ["bert","platt",0.5724,0.6000,15], ["bert","platt",0.6348,0.6250,16],
    ["bert","platt",0.6918,0.6000,15], ["bert","platt",0.7690,0.7179,39], ["bert","platt",0.8397,0.6471,51],
    ["bert","platt",0.9091,0.7750,200], ["bert","platt",0.9833,0.9860,9134], ["bert","iso",0.0220,0.0427,164],
    ["bert","iso",0.1050,0.0000,2], ["bert","iso",0.1676,0.1479,169], ["bert","iso",0.3018,0.1250,16],
    ["bert","iso",0.3333,0.3966,58], ["bert","iso",0.4762,0.5248,101], ["bert","iso",0.5416,1.0000,1],
    ["bert","iso",0.6419,1.0000,2], ["bert","iso",0.7228,0.6591,220], ["bert","iso",0.7975,0.8108,74],
    ["bert","iso",0.8237,0.7143,42], ["bert","iso",0.9168,0.9276,1105], ["bert","iso",0.9931,0.9937,8046]
  ];
  return raw.map(([model, method, conf, freq, n]) => ({model, method, conf, freq, n}));
}

viewof relModel = Inputs.radio(
  new Map([
    ["dengesizlik düzeltmesi yapılmamış tf-idf", "plain"],
    ["aynı model, class_weight=balanced", "weighted"],
    ["BERTurk, fit dilimi üzerinde fine-tune edilmiş", "bert"]
  ]),
  { value: "plain", label: "model" }
)

viewof relPick = Inputs.checkbox(
  new Map([
    ["ham — modelin dediği", "raw"],
    ["sıcaklık — tek parametre", "temp"],
    ["Platt — eğim ve sabit terim", "platt"],
    ["izotonik — serbest monoton eşleme", "iso"],
    ["TRAIN üzerinde ayarlanmış izotonik (sızıntı)", "leak"]
  ]),
  { value: ["raw", "platt"], label: "kalibrasyon" }
)

relPlot = {
  // yalnızca düzeltilmemiş doğrusal modelin kasıtlı sızdırılmış kalibratörü var
  const avail = relModel === "plain"
    ? ["raw", "temp", "platt", "iso", "leak"]
    : ["raw", "temp", "platt", "iso"];
  const keep = relPick.filter(m => avail.includes(m));
  const data = relRows.filter(d => d.model === relModel && keep.includes(d.method));
  const names = {raw: "ham", temp: "sıcaklık", platt: "Platt",
                 iso: "izotonik", leak: "TRAIN üzerinde izotonik"};
  return Plot.plot({
    width: 640,
    height: 440,
    marginLeft: 60,
    marginBottom: 48,
    x: { label: "kutucuktaki ortalama öngörülen P(memnun)", domain: [0, 1], grid: true },
    y: { label: "kutucukta gözlenen memnun payı", domain: [0, 1], grid: true },
    r: { range: [2, 14] },
    color: { legend: true, domain: ["raw", "temp", "platt", "iso", "leak"],
             range: ["#B3453E", "#C08A3E", "#1F4E79", "#0E7C7B", "#6B7280"],
             tickFormat: k => names[k] },
    marks: [
      Plot.line([[0, 0], [1, 1]], { stroke: "currentColor", strokeDasharray: "5 4" }),
      Plot.line(data, { x: "conf", y: "freq", stroke: "method", strokeWidth: 1.5, strokeOpacity: 0.55 }),
      Plot.dot(data, { x: "conf", y: "freq", fill: "method", r: "n", fillOpacity: 0.75,
        title: d => `${names[d.method]}\nöngörülen ${(100*d.conf).toFixed(1)}%\n` +
                    `gözlenen ${(100*d.freq).toFixed(1)}%\n${d.n.toLocaleString("tr-TR")} belge` })
    ]
  });
}

Modeli class_weight=balanced’a çevirin ve yalnızca ham’ı işaretli bırakın. Eğrinin tamamı köşegenin üstünde duruyor: her kutucuk, modelin öngördüğünden daha fazla memnun yorum içeriyor. Bu gürültü değil, her olasılığın sistematik olarak aşağı kaymasıdır — ve sonraki birkaç paragrafın konusu da bu.

Test üzerindeki gerçek taban oran 0,9368. Tablodan beş bulgu çıkıyor.

Sınıf ağırlıklandırma kalibrasyonu yok ediyor. ECE 3,96’dan 14,18’e çıkıyor, yani 3,6× artış; modelin ortalama öngörülen olasılığı da gerçek oran 0,9368 iken 0,795’e düşüyor. Yeniden ağırlıklandırılmış model macro-F1 bakımından daha iyi (58,24’e karşı 76,09) ve olasılıkları çok daha kötü. Modelinizin çıktısı bir insana gösterilecekse, bir maliyetle çarpılacaksa ya da başkasının yazdığı bir kuralla eşiklenecekse, sınıf ağırlıklandırma üçünü de sessizce bozar. Bu, van den Goorbergh ve arkadaşlarının sonucunun metin üzerinde yeniden üretilmiş hâli.

Sıcaklık ölçeklemesi olsa olsa yolun yarısına kadar götürüyor ve bu, kötü şanstan çok yapısal bir olgu. Sıcaklığın tek bir parametresi var; sıralamayı ve argmax’ı koruyor ve ikili bir problemde olasılıkları yalnızca 0,5 kesiği etrafında simetrik biçimde ortaya ya da uçlara doğru itebiliyor. Sınıf ağırlıklı modelde bozuk olan şey ise kaymış bir önsel. class_weight="balanced" her sınıfa \(w_c = n/(K\,n_c)\) ağırlığı veriyor (\(n\) belge sayısı, \(K\) sınıf sayısı, \(n_c\) o sınıftaki belge sayısı); fit diliminde bu, şikâyet için ≈ 7,91, memnun için ≈ 0,53 demek. Kayıp fonksiyonu her şikâyeti kabaca 15 memnun yorum kadar sayıyor, model de şikâyetleri olduklarından daha yaygın sanıyor — ve bunun düzeltilmesi için her logit’in esnetilmesi değil, aynı miktarda kaydırılması gerekir. Sıcaklık ortalamayı ancak keskinleştirmenin bir yan etkisi olarak oynatabilir: burada ortalama tahmini 0,795’ten 0,859’a çıkarıyor, ECE de 14,18’den 7,80’e iniyor; sonra oynatacak başka parametresi kalmıyor. Platt ölçeklemesinin iki parametresi var: bir eğim ve bir sabit terim (Platt 1999). Sabit terim de bir önsel kaymasını düzelten düğmenin ta kendisi. ECE’yi 14,18’den 0,93’e indiriyor.

Sıcaklık ölçeklemesini yaygınlaştıran Guo ve arkadaşları, onun görüntü ve metin sınıflandırıcılarında güçlü bir baseline olduğunu gördü (Guo vd. 2017). Bu, buradaki sonuçla çelişmiyor: onların ağları aşırı kendinden emindi ama sistematik olarak kaymış değildi — sıcaklığın tasarlandığı başarısızlık türü de bu. Burada sıcaklık ölçeklemesine başvurmak, iki parametreli bir soruna tek parametreli bir çözümle yaklaşmak demek.

ECE ile MCE anlaşamıyor ve hiçbiri tek başına yetmiyor. Sınıf ağırlıklı model üzerinde izotonik regresyon (isotonic regression), kendi grubundaki en iyi ECE’yi (0,88) ve tablodaki en kötü MCE’yi (72,20) alıyor. ECE bir \(n\) ağırlıklı ortalama; dolayısıyla büyük açığı olan tek bir seyrek kutucuk onu neredeyse hiç oynatmıyor. MCE ise kutucuk büyüklüğüne hiç bakmıyor; tek bir seyrek kutucuk onu belirleyebiliyor. Burada o kutucukta tek bir belge var: izotonik eşleme onu 0,278’e koymuş, belge de memnun çıkmış. Aynı modelde bir sonraki en büyük açık da tek belgelik bir kutucukta (46,2 puan); tek belgelik kutucukları saymazsak en büyük açık 40 belgelik bir kutucukta 9,0 puan. Yani 72,20 kuyruğu değil, tek bir yorumu anlatıyor: ECE’nin altına bir taban koyan binom gürültüsü, MCE’nin altına çok daha yüksek bir taban koyuyor. Kararlarınız dağılımın kuyruğuna dayanıyorsa — maliyete duyarlı kararlar genellikle öyledir — ortalama yanlış bir özet, maksimum ise gürültülü bir özettir. Güvenilirlik diyagramına kutucuk sayılarıyla birlikte bakın; yukarıdaki widget’taki nokta büyüklükleri tam bunun için var.

isotonic regression (izotonik regresyon) — kalibrasyon eşlemesini, monoton azalmayan ve basamaklı olabilen serbest bir fonksiyon olarak öğrenir. Bir sigmoid’in bükülemediği her monoton şekle bükülebilir; yeterince ayrılmış veri varken kazanmasının, yokken aşırı öğrenmesinin nedeni budur. ↩︎

Kalibratörü eğitim verisi üzerinde ayarlamak bozuk görünmüyor. “isotonic fitted on TRAIN” diye işaretli satır, bu kısmın asıl uyarmak istediği hata: izotonik eşlemeyi, sınıflandırıcının eğitildiği aynı 32.000 belge üzerinde ayarladık. ECE 2,39 alıyor. Bu, ayrılmış veri üzerinde düzgünce ayarlamaktan (0,69) 1,7 puan daha kötü — ve yine de hiçbir şey yapmamaktan iyi (3,96). Sızıntı, bariz biçimde yanlış bir sayı üretmiyor. Elde edebileceğinizden sessizce ve belirgin biçimde kötü, makul görünen bir sayı üretiyor; kod incelemesinde fark edilmemesinin nedeni de bu.

Transformer ortalamada daha iyi, kuyrukta daha kötü kalibre. BERTurk’ün ham ECE’si, doğrusal modelin 3,96’sına karşı 2,53; Brier puanı 0,0421’e karşı 0,0318; 0,933’lük ortalama öngörüsü ise gerçek taban orandan binde dörtten az sapıyor. Yani derin ağların aşırı derecede kendinden emin olduğuna dair yaygın kanı burada toplamda yeniden üretilmiyor. Yeniden üretilen şey öbür sütunda: BERTurk’ün maksimum kalibrasyon hatası 49,84, tablodaki en kötü ham değer. Bir yerde, modelin bir şey dediği ve verinin 50 puan ötede başka bir şey dediği bir kutucuk var — Bölüm 12.10 size orada tam olarak hangi belgelerin bulunduğunu gösterecek. Kalibrasyon ortalamayı düzeltiyor. İzotonik, ECE’yi 0,56’ya indiriyor; bu değer, mevcut kutucuk yapısında kusursuzdan ayırt edilemez. Üstelik bölümün en iyi Brier ve log loss değerlerini de veriyor; burada gerçekten keskin olan istatistikler de bunlar. MCE 45,84’te kalıyor, ama kalibrasyondan sonra bu sayı tek belgelik bir kutucuktan geliyor, yani pek bir şey söylemiyor. Asıl bulgu ham modelin kuyruğu: 11, 13 ve 20 belgelik en kötü üç kutucuğu 44,7 ile 49,8 puan arası sapıyor.

Bu BERTurk, 40.000’lik train üzerinde değil 32.000 belgelik fit dilimi üzerinde fine-tune edildi; tam da cal dokunulmamış kalsın diye. Bu da onu fine-tuning kısmındaki modelden (Bölüm 12.3) biraz daha zayıf bir sınıflandırıcı yapıyor — 85,02’ye karşı 84,45 macro-F1, yani 8.000 eksik etiketin bedeli — ve sızıntısız kalibre edilebilecek tek model de bu. 40.000 etiketli modeli burada yeniden kullanmak, kalibratörü modelin zaten eğitimde gördüğü 8.000 belge üzerinde ayarlamak olurdu — “isotonic on TRAIN” satırının ölçtüğü sızıntının ta kendisi.

Eğitim verisi üzerinde kalibrasyona karşı uyarı Platt’ın kendisinden gelir ve genellikle abartılır. Asla eğitim kümesi üzerinde ayarlamayın demiyor; doğrusal olmayan SVM’ler için bunun “bazen felaket ölçüsünde yanlı kestirimlere yol açtığını”, doğrusal modeller içinse “sigmoid’i doğrudan eğitim kümesi üzerinde ayarlamanın çoğu zaman mümkün olduğunu” söylüyor. Bizim modelimiz doğrusal ve gerçekten de buradaki sızıntı kötü ama felaket değil. Önerdiği çare üç katlı çapraz doğrulama; daha ucuz alternatif olarak da “tipik olarak %30”luk ayrılmış bir küme (Platt 1999).

12.6.1 Hangi ECE üzerine bir not

Beklenen kalibrasyon hatası tek bir istatistik değil. Guo ve arkadaşları en üst etiket güveni \(\max_k p_k\) üzerinden kutucuklara ayırıyor ve argmax’ın ne sıklıkta doğru olduğunu soruyor (Guo vd. 2017). İkili bir problemde bu nicelik \([0{,}5, 1]\) aralığında değer alır; dolayısıyla kutucukların yarısı yapısı gereği boştur ve sayı, doğrudan \(P(\text{sınıf } 1)\) üzerinden kutulamayla karşılaştırılabilir değildir. Ölçüm kodumuz ikisini de raporluyor; yukarıdaki tablo ikili sürümü kullanıyor ve en üst etiket sürümü sistematik olarak daha küçük — sınıf ağırlıklı model için 14,18 yerine 8,98.

Bu seçim kozmetik bir ayrıntı değil; BERTurk’e sıcaklık ölçeklemesi uygulamak bunun nedenini gösteriyor. İkili istatistikte işleri kıl payı kötüleştiriyor, 2,53 → 2,58. En üst etiket istatistiğinde ise büyük bir kazanç gibi görünüyor, 2,47 → 0,73. Aynı model, aynı ayarlanmış sıcaklık, aynı test kümesi, tek bir işlem — yalnızca hangi ECE’yi yazdırdığınıza bağlı olarak 3,4× iyileşme ya da küçük bir gerileme diye raporlanıyor. İki sayı da doğru ve farklı sorulara cevap veriyorlar: memnun olasılığının ne kadar iyi kalibre olduğu ile hangi etiket kazandıysa ona duyulan güvenin ne kadar iyi kalibre olduğu. Hangisini hesapladığınızı söylemeden bir ECE aktarmak yanlıştır.

İkinci bir serbestlik derecesi daha var ve bu derlemde daha büyük olan o: kaç kutucuk ve nasıl çizildikleri. Bizimkiler eşit genişlikte on beş tane ve bu kadar çarpık bir dağılımda en üst kutucuk test kümesinin %73’ünü tutarken on kutucuğun her biri yüzden az belge tutuyor — yani istatistiğe bir avuç kutucuk karar veriyor. Eşit kütleli (uyarlamalı) kutulama her kutucuğa aynı sayıda belge koyar ve aynı model için başka bir sayı verir (Nixon vd. 2019). İki şema da binom gürültüsüyle yukarı yanlı; yukarıdaki yarım puanlık gürültü tabanı da oradan geliyor ve bunu azaltmak için tasarlanmış kestiriciler var (Kumar vd. 2019; Roelofs vd. 2022). Kutucuk sayısını, kutulama şemasını ve — iddia ettiğiniz fark bir puanın altındaysa — bir bootstrap aralığını raporlayın.

12.7 Eşiği bir maliyet matrisinden seçmek

Şimdi bütün bunların karşılığını alıyoruz. Modelin çıktısı bir olasılıksa, eşik için tarama yapmak zorunda değilsiniz — türetebilirsiniz.

\(q = P(\text{şikâyet} \mid x)\) olsun ve bir yanlış alarmın maliyeti \(C_{FP}\), kaçırılan bir şikâyetin maliyeti \(C_{FN}\) olsun. İşaretlemenin maliyeti \((1-q) \cdot C_{FP}\); geçmesine izin vermenin maliyeti \(q \cdot C_{FN}\). İşaretlemeye şu durumda değer:

\[q > \frac{C_{FP}}{C_{FN} + C_{FP}} = \frac{1}{1+r}, \qquad r = \frac{C_{FN}}{C_{FP}}\]

Bu, Elkan’ın eşiği (Elkan 2001) ve aktarılırken sık sık atlanan bir koşulla birlikte geliyor: \(q\)’nün bir olasılık olması gerekiyor. Olmadığında ne olduğu aşağıda. Maliyetler \(C_{FP} = 1\) birim alınarak 10.000 belgelik test kümesi üzerinde hesaplandı. “oracle”, doğrudan test üzerinde tarama yapılarak bulunan mümkün olan en iyi eşik; dolayısıyla her satırın bir pişmanlığı var.

  r    Elkan q*    raw    calibrated   swept    oracle | regret: raw   calib   swept
  1      0.5000    572           501     498       483 |      18.4%    3.7%    3.1%
  2      0.3333    980           797     792       776 |      26.3%    2.7%    2.1%
  5      0.1667   1575          1357    1357      1342 |      17.4%    1.1%    1.1%
 10      0.0909   2218          2173    2167      2052 |       8.1%    5.9%    5.6%
 25      0.0385   4395          3551    3558      3479 |      26.3%    2.1%    2.3%
 50      0.0196   6764          4626    4546      4345 |      55.7%    6.5%    4.6%
100      0.0099   8373          5645    5647      5416 |      54.6%    4.2%    4.3%

Doğru formülü kalibre edilmemiş puanlara uygulamak %8 ile %56 arasında fazla harcatıyor. Aynı modelin izotonik kalibre edilmiş puanlarına uygulamak %1 ile %7 arasında fazla harcatıyor. Sorun hiçbir zaman formül değildi.

Mekanizma işaretleme sayılarında görünüyor. \(r = 100\)’de ham model, 9.368 memnun yorumdan 8.073’ü için yanlış alarm veriyor — mutlu müşterilerin %86’sını işaretliyor — çünkü puanları, 0,0099’luk bir eşiğin neredeyse her şeyi yakaladığı bir bölgeye sıkışmış durumda. Kalibre model ise 3.345 yanlış alarm veriyor ve 3 yerine 23 şikâyet kaçırıyor. İkisi de neredeyse her şikâyeti yakalıyor; biri bunu yaparken ekibi yanlış alarma boğuyor.

costRows = [
  {r: 1,   qstar: 0.5000, raw: 572,  cal: 501,  swept: 498,  oracle: 483,  none: 632,   all: 9368, fpRaw: 9,    fnRaw: 563, fpCal: 140,  fnCal: 361, regRaw: 18.4, regCal: 3.7, regSwept: 3.1},
  {r: 2,   qstar: 0.3333, raw: 980,  cal: 797,  swept: 792,  oracle: 776,  none: 1264,  all: 9368, fpRaw: 38,   fnRaw: 471, fpCal: 279,  fnCal: 259, regRaw: 26.3, regCal: 2.7, regSwept: 2.1},
  {r: 5,   qstar: 0.1667, raw: 1575, cal: 1357, swept: 1357, oracle: 1342, none: 3160,  all: 9368, fpRaw: 270,  fnRaw: 261, fpCal: 492,  fnCal: 173, regRaw: 17.4, regCal: 1.1, regSwept: 1.1},
  {r: 10,  qstar: 0.0909, raw: 2218, cal: 2173, swept: 2167, oracle: 2052, none: 6320,  all: 9368, fpRaw: 1198, fnRaw: 102, fpCal: 1083, fnCal: 109, regRaw: 8.1,  regCal: 5.9, regSwept: 5.6},
  {r: 25,  qstar: 0.0385, raw: 4395, cal: 3551, swept: 3558, oracle: 3479, none: 15800, all: 9368, fpRaw: 4020, fnRaw: 15,  fpCal: 2051, fnCal: 60,  regRaw: 26.3, regCal: 2.1, regSwept: 2.3},
  {r: 50,  qstar: 0.0196, raw: 6764, cal: 4626, swept: 4546, oracle: 4345, none: 31600, all: 9368, fpRaw: 6464, fnRaw: 6,   fpCal: 2776, fnCal: 37,  regRaw: 55.7, regCal: 6.5, regSwept: 4.6},
  {r: 100, qstar: 0.0099, raw: 8373, cal: 5645, swept: 5647, oracle: 5416, none: 63200, all: 9368, fpRaw: 8073, fnRaw: 3,   fpCal: 3345, fnCal: 23,  regRaw: 54.6, regCal: 4.2, regSwept: 4.3}
]

viewof costRatio = Inputs.radio(
  new Map([
    ["r = 1 — bir yanlış alarm ile kaçırılan bir şikâyet aynı maliyette", 1],
    ["r = 2", 2],
    ["r = 5 — kaçırılan bir şikâyet beş yanlış alarma bedel", 5],
    ["r = 10", 10],
    ["r = 25", 25],
    ["r = 50", 50],
    ["r = 100 — kaçırılan bir şikâyet yüz yanlış alarma bedel", 100]
  ]),
  { value: 25, label: "maliyet oranı" }
)

costPlot = {
  const row = costRows.find(d => d.r === costRatio);
  const bars = [
    {policy: "hiçbir şeyi işaretleme", cost: row.none, kind: "trivial"},
    {policy: "her şeyi işaretle", cost: row.all, kind: "trivial"},
    {policy: "ham puanlarda Elkan q*", cost: row.raw, kind: "bad"},
    {policy: "kalibre puanlarda Elkan q*", cost: row.cal, kind: "good"},
    {policy: "cal üzerinde taranmış eşik", cost: row.swept, kind: "good"},
    {policy: "oracle — test üzerinde taranmış", cost: row.oracle, kind: "oracle"}
  ];
  return Plot.plot({
    width: 700,
    height: 300,
    marginLeft: 210,
    marginBottom: 50,
    x: { label: `10.000 belgelik test kümesinde toplam maliyet, bir yanlış alarm birimiyle — q* = ${row.qstar.toFixed(4)}`,
         grid: true },
    y: { label: null, domain: bars.map(d => d.policy) },
    color: { domain: ["trivial", "bad", "good", "oracle"],
             range: ["currentColor", "#B3453E", "#0E7C7B", "#1F4E79"], legend: false },
    marks: [
      Plot.barX(bars, { y: "policy", x: "cost", fill: "kind", rx: 3,
        title: d => `${d.policy}\n${d.cost.toLocaleString("tr-TR")} maliyet birimi` }),
      Plot.text(bars, { y: "policy", x: "cost", text: d => d.cost.toLocaleString("tr-TR"),
        dx: 6, textAnchor: "start", fontWeight: 600 }),
      Plot.ruleX([row.oracle], { stroke: "#1F4E79", strokeDasharray: "4 3" })
    ]
  });
}

Oranı 1’den 100’e adım adım artırın ve kırmızı çubuğu izleyin. \(r = 10\)’da ham puan politikası kabul edilebilir düzeyde; en iyi eşiğin yalnızca %8 üstünde. 50’nin altındaki diğer bütün oranlarda %17–26 fazla harcıyor. \(r = 50\)’de ise mevcut en iyi eşikten %56 daha pahalıya mal oluyor. Kalibre edilmemiş puanlar, tam da riskin en yüksek olduğu yerde en kötü sonucu veriyor, çünkü \(q^*\) orada modelin sıkıştırmış olduğu puan aralığına giriyor.

\(r = 1\)’de olanlara dikkat edin; orada Elkan’ın eşiği tanıdık 0,5. Ham model 78 belge işaretliyor ve 632 şikâyetin 563’ünü kaçırıyor. Bu, dengesizlik kısmındaki 58,24 macro-F1’in (Bölüm 12.5) arkasındaki sorunun ta kendisi; yalnızca bu kez maliyet açısından bakıyoruz. Eşit maliyetlerde ders kitabı eşiği 0,5’tir ve kalibre edilmemiş, dengesiz bir modelde 0,5 doğru eşiğin yakınından bile geçmez.

Maliyeti en aza indiren eşik için doğrudan cal üzerinde tarama yapmak, kalibre edip sonra formülü uygulamakla aşağı yukarı aynı iş görüyor — %1 ile %6 arası pişmanlığa karşı %1 ile %7. Bu, gerçekten yararlı ve pratik bir bulgu: tek bir sabit maliyet oranı için tek bir çalışma noktası gerekiyorsa, kalibrasyonu atlayıp tarama yapabilirsiniz. Kalibrasyon ise maliyetler değişebiliyorsa, sayı bir insana gösteriliyorsa ya da işlem hattında sonraki bir adım onu bir şeyle çarpıyorsa yerini hak eder.

Kıyas için iki basit politika: hiçbir şeyi işaretlememek \(632r\) maliyetinde, yani \(r=100\)’de 63.200; her şeyi işaretlemek ise \(r\)’den bağımsız olarak 9.368. \(r = 100\)’de ham modelin 8.373’ü, derlemin tamamını işaretlemekten kıl payı iyi.

12.8 LLM’lerle zero-shot ve few-shot

Buraya kadar her şey elinizde etiket olduğunu varsaydı. Çoğu proje hiç etiket olmadan başlar. Bu kısmın ölçümlerle cevapladığı soru şu: genel amaçlı bir model, ona yalnızca sorduğunuzda kaç puan alıyor ve — gerçek projelerde asıl belirleyici olan da bu — elinizde makul olarak bulunabilecek her etiket bütçesinde fine-tune edilmiş bir encoder’la nasıl kıyaslanıyor?

Zero-shot classification (sıfır atışlı sınıflandırma) bariz bir nedenle çekici: etiketleme bütçesi sıfır ve model bugün yayına alınabilir. Prompt’a bir avuç etiketli örneğin eklendiği few-shot (az örnekli) sürümü de bütçeyi neredeyse sıfırda tutar. Aynı zamanda bu bölümde kurduğumuz her aracın çalışmayı bıraktığı durumdur — sayıları dikkatle okumanın daha az bariz nedeni de bu.

O ilk cümleye bir düzeltme gerekiyor; bu kısmın kendisi de bunun kanıtı. Eğitim için etiketleme bütçesi sıfır. Modelin işe yarayıp yaramadığını öğrenmenin bütçesi ise sıfır değil: aşağıdaki her sayı 2.000 etiketli belgeye dayanıyor ve sizin de kendinize ait bir değerlendirme kümesine ihtiyacınız olacak.

zero-shot classification (sıfır atışlı sınıflandırma) — yalnızca bir talimattan, hiç örnek ve hiç eğitim olmadan etiketleme. Model bir puan değil bir kelime döndürür, dolayısıyla kaydırılacak bir eşik ve ayarlanacak bir kalibrasyon eşlemesi yoktur. Dengesizlik, kalibrasyon ve maliyet kısımlarındaki her teknik (Bölüm 12.5, Bölüm 12.6, Bölüm 12.7) 0 ile 1 arasında bir sayıya ihtiyaç duyar; bu durum size o sayıyı vermez. ↩︎

12.8.1 Karşılaştırmayı adil tutmak

Promptlu bir modelle fine-tune edilmiş bir modelin karşılaştırması, ikisi de aynı belgeler üzerinde puanlanmadıkça hiçbir işe yaramaz. 10.000 yorumu 27B’lik bir modelden geçirmek, dizüstü bilgisayarın ne kadar meşgul olduğuna göre koşul başına 1,6 ile 2,4 saat arası sürüyor. Düşük rakam medyandan, yüksek rakam ise fiilen gözlediğimiz wall-clock süresinden (gerçekte geçen süre) geliyor. Bu yüzden LLM koşuları aynı test diliminin tabakalı 2.000 belgelik bir altörneklemini kullanıyor: 1.874 memnun ve 126 şikâyet, yani tam dilimin %6,32’sine karşılık %6,30’luk bir azınlık oranı.

Bunu meşru kılan kural, geri kalan her şeyin de o özdeş altörneklem üzerinde yeniden puanlanmış olması. Bu kısımdaki tf-idf ve BERTurk sayıları önceki kısımların sayıları değil; aynı modellerin, LLM’lerin gördüğü aynı 2.000 belge üzerinde, aynı sırayla okunmuş hâlleri.

re-scored on the 2,000-document subsample     acc   macro-F1  95% CI

always "satisfied"                           93.70    48.37
tf-idf + LR, class-weighted                  93.40    78.20   [74.77, 81.36]
tf-idf + LR, threshold moved to 0.166        95.40    80.23   [76.35, 83.60]
BERTurk fine-tuned,    200 labels            92.25    52.65   [49.77, 55.93]
BERTurk fine-tuned,    500 labels            93.70    59.47   [55.04, 63.97]
BERTurk fine-tuned,  1,000 labels            94.95    72.78   [68.12, 77.02]
BERTurk fine-tuned,  2,000 labels            96.05    82.00   [78.13, 85.42]
BERTurk fine-tuned,  5,000 labels            95.35    81.21   [77.57, 84.51]
BERTurk fine-tuned, 10,000 labels            96.65    84.97   [81.40, 88.07]
BERTurk fine-tuned, 20,000 labels            96.50    84.84   [81.21, 87.94]
BERTurk fine-tuned, 40,000 labels            96.85    86.81   [83.42, 89.60]

Tablodaki 5.000 etiket satırının (81,21) 2.000 etiket satırının (82,00) altında kalmasının en olası sebebi, öğrenme eğrisini okurken işaret ettiğimiz takvim değişikliği (Bölüm 12.3): 2.000 etiketli model örnek başına neredeyse yedi kat daha fazla gradyan güncellemesi aldı. Güven aralıklarının örtüşüp örtüşmediğine bakarak bu farkı ne doğrulayabilir ne de yok sayabilirsiniz. Aynı belgeler üzerinde puanlanan iki model örneklem gürültüsünün büyük kısmını paylaşır; iki modeli karşılaştırmanın doğru yolu, aşağıda kullandığımız eşleştirilmiş bootstrap.

Bunlar, baseline ve fine-tuning kısımlarındaki (Bölüm 12.2, Bölüm 12.3) sayılar değil ve olmamaları da gerekiyor. Oradakiler 10.000’in tamamı üzerinde okunmuştu; buradakiler ise aynı eğitilmiş modellerin, o 10.000’in 2.000’i üzerinde okunmuş hâlleri. 500 etiketli BERTurk burada 59,47, orada 56,46 alıyor — aynı model, farklı dilim. Bu iki kısımda geçen her rakam bu altörnekleme bağlı, dolayısıyla hiçbirini bölümün önceki kısımlarındaki bir sayıyla karşılaştırmayın.

Çoğunluk sınıfı baseline’ının burada %93,70 doğruluk olduğuna dikkat edin. Bu kısımda 9 ile başlayan her doğruluk rakamını sezgilerinizle değil, o sayıyla karşılaştırarak okuyun.

Aralıklar, 2.000 belge üzerinde 2.000 yeniden örneklemeli bootstrap’lar. Genişler — kabaca ±3,5 puan — çünkü 126 şikâyet fazla bir sayı değil ve macro-F1’in asıl ölçtüğü şey azınlık sınıfı. Altörneklem size karşılanabilir LLM koşuları kazandırır ve bunu çözünürlükle öder; doğru tepki de nokta tahminini bulgu gibi sunmak yerine aralığın kendisini raporlamaktır.

Dört model koştu, hepsi tek bir dizüstü bilgisayarda ollama üzerinden 4 bit’e nicemlenmiş (Q4_K_M) hâlde — bunu açıkça söylemekte fayda var: bunlar bir API’nin arkasındaki frontier modeller değil. Yanınızda taşıyabileceğiniz bir makineye sığan şeyler.

Dört yerel model, hepsi Q4_K_M nicemlenmiş

model	parametre	diskte	not
llama3.2:3b	3,2B	2,0 GB	aralığın küçük model ucu; düşünme kipi yok, think: false testinde kontrol grubu olmasının sebebi de bu
qwen3.5:9b	9,7B	6,6 GB	yoğun, iş beygiri — ve bir akıl yürüten model, aşağıdaki bozuk koşu tamamen bununla ilgili
gemma3:27b	27,4B	17,4 GB	yoğun, buradaki en büyüğü
qwen3.6:35b-a3b	36,0B toplam, ~3B aktif	23,9 GB	mixture-of-experts (uzman karışımı; Bölüm 7.7), o da bir akıl yürüten model

4 bit’e nicemlenmiş olması, ağırlıkların çoğunun on altı bit yerine dört bitte saklanması demek. Q4_K_M bazı tensörleri daha yüksek hassasiyette tutar ve her küçük ağırlık bloğu için ayrıca bir ölçek saklar; bu yüzden ortalama beş bite daha yakındır: gemma3:27b’nin 27,4B ağırlığı 17,4 GB tutuyor, 16 bitte gerekecek 55 GB’ın kabaca üçte biri. Aslına uygunluktan ödenen bedel genelde küçük, ama asla sıfır değil. 27B’lik bir modelin dizüstü bilgisayara sığabilmesini sağlayan da bu nicemleme. Ayrıca bu karşılaştırmanın promptlu tarafa pek de adil olmadığı anlamına geliyor: BERTurk tam hassasiyette koştu, bunlar koşmadı. Nicemlenmemiş sürümleri ölçemedik çünkü makineye sığmıyorlar; o hâlde kesişimi yerel olarak koşturabileceğiniz modeller için ölçülmüş kabul edin ve tam hassasiyetli ya da barındırılan bir modelin kesişimi daha yüksek etiket bütçelerine, yani sağa kaydıracağını bekleyin.

12.8.2 Tamamen bozuk olduğu için %93,75 alan koşu

Sonuçlardan önce, az kalsın yayımlanacak olan hataya bakalım, çünkü bu kısımdaki en faydalı şey o.

Bu matrisin ilk geçişinde qwen3.5:9b, koşu durdurulmadan önce işleyebildiği 400 belge üzerinde %93,75 doğruluk ve 48,39 macro-F1 aldı. Bu iki sayıyı yukarıdaki tablodakilerle karşılaştırın: 93,70 ve 48,37. Model her belgede “memnun” tahmin ediyordu ve bunun karşılığında kazandığı puan, yuvarlama hatası kadar bir farkla, çoğunluk sınıfı baseline’ı.

Aşağıda o koşudan arşivlenmiş bir kaydı olduğu gibi görüyorsunuz; 400 kaydın hepsi buna benziyor:

{"i": 0, "y": 1, "pred": 1, "conf": null, "ok": false, "raw": "",
 "secs": 2.408, "eval_count": 24, "prompt_eval_count": 99}

           raw : ''    <- ayrıştırıcının okuduğu alan; 400 kaydın hepsinde boş.
    eval_count : 24    <- üretilen token: 400 kaydın hepsinde tam sınırda.
    parse rate : 0.0%  <- bakmadığımız alan.

qwen3.5 bir akıl yürüten model. ollama onun düşünce zincirini ayrı bir thinking alanında döndürüyor ve düşünme bitene kadar response alanı boş kalıyor. num_predict 24 token’da sınırlıyken bütçenin tamamı akıl yürütme bloğunun içinde harcandı, response hiç yazılmadı, her cevap ayrıştırmada başarısız oldu ve her belge yedek etikete düştü. Yedek etiket de çoğunluk sınıfıydı; sonucun bir çökme gibi değil de makul görünmesinin sebebi bu.

Arşivlenmiş kaydın neyi içermediğine dikkat edin: düşünme alanına dair hiçbir iz yok, üretimin neden durduğuna dair de. Değerlendirme düzeneği bunları kaydetmiyordu; bu yüzden teşhis için log’a bakmak değil, modele yeni bir sorgu atmak gerekti. think_chars ve done_reason artık şemada; bu yüzden eklendiler. Bir log alanı genellikle böyle doğar.

Bu derlemde %93,75 doğruluk bir sonuç değil. Yedek etiketi çoğunluk sınıfı olan bozuk bir değerlendirme düzeneği işte böyle görünür. Bu matristeki on koşunun altısı aynı kusuru taşıyacaktı.

Üç değişiklik sorunu çözdü ve yalnızca ilki hatayla ilgili:

1. think: false gönder; bu alanı reddeden modeller için de alan olmadan yeniden deneyen bir yedek ekle. Ayrıştırma oranı %0,0’dan %100,0’a çıktı. Düşünme kipi olmayan llama3.2:3b üzerindeki çıktı ise bayt bayt aynı kaldı; bu da bayrağın, etkisiz olması gereken yerde gerçekten etkisiz olduğunu doğruladı.
2. Dokuz saatlik GPU zamanını çoğunluk sınıfı baseline’larından oluşan bir tablo üretmeye harcamak yerine, ilk 40 cevabının ayrıştırma oranı %50’nin altında kalan koşuyu iptal et.
3. Makineyi bir gecelik kuyruğa bağlamadan önce altı model/koşul kombinasyonunun hepsini 24’er belge üzerinde duman testinden (smoke test) geçir.

Bu üç düzeltmenin söylemediği ve söylemesi gereken kural. Üçü de bu olaya özgü: biri hata düzeltmesi, ikisi nöbetçi. Genel kural daha basit ve akılda tutulması gereken de o — ayrıştırılamayan bir cevap bir tahmin değildir. Onun bir etikete düşmesine asla izin vermeyin: ne çoğunluk sınıfına, ne rastgele bir sınıfa, ne de bir önceki belgenin cevabına. unparseable adında üçüncü bir sonuç üretin ve raporladığınız her metriğe onu da taşıyın: ayrıştırılabilen belgeler üzerindeki doğruluk ile ayrıştırma oranı, yan yana. Belgelerin %60’ında %95 doğrulukla cevap veren bir model, her seferinde %57 doğrulukla cevap veren bir modelden farklı bir üründür. İkisini bütün belgeler üzerinden, cevapsızları yanlış sayarak puanlarsanız aynı görünürler: ikisi de %57. Birincisine bu derlemde çoğunluk sınıfını yedek etiket olarak verirseniz yaklaşık %94 alır ve daha iyi model gibi görünür. İkisini ancak iki sayı birlikte ayırt eder. Dikkat edin: tek başına iptal nöbetçisi bizi kurtarmazdı — ayrıştırma oranı %55 olan bir koşu o eşiği geçer ve kalan %45’i sessizce çoğunluk sınıfıyla doldurur. Her çağrıda ham cevabı, bitiş sebebini ve akıl yürütme alanının uzunluğunu kaydedin; çünkü teşhis için ihtiyaç duyacağınız alan her zaman kaydetmeyi düşünmediğiniz alandır.

Bu, fine-tuning kısmındaki (Bölüm 12.3) 27 katlık çıkarım aykırı değeriyle aynı ders; yalnızca ters yönden geliyor. Orada sayı inanılmayacak kadar kötüydü ve kabahat değerlendirme düzeneğindeydi. Burada sayı rahatlatıcı ölçüde iyiydi ve kabahat yine değerlendirme düzeneğindeydi. Kötü sayı soruşturulur; iyi sayı yayımlanır. Tasarımda önlem alınması gereken şey hatanın kendisi değil, bu asimetri; iptal koruması da bunu yapıyor.

Aşağıda raporlanan her koşuda ayrıştırma oranı %100,0.

12.8.3 Sonuçlar

Dört model, üç prompt ayarı, tek bir derlem. İlginç olan karşılaştırma hangi modelin kazandığı değil; sonuçlar arasındaki açıklığın ne kadarının model boyutuyla, ne kadarının hiçbir maliyeti olmayan şeylerle açıklandığı.

2,000 documents, temperature 0, seed 42, single process. Every run parsed 100%.
                             acc  macroF1   95% CI       cP     cR    cF1   s/doc  prompt
                                                                                    tokens
llama3.2:3b      zero/tr   66.35    52.32  [50.10,54.68]  15.34  96.03  26.45  0.121   140
llama3.2:3b      zero/en   87.80    69.21  [65.98,72.38]  31.56  80.16  45.29  0.124   123
gemma3:27b       zero/tr   88.65    72.28  [69.18,75.28]  35.01  93.65  50.97  0.592   124
qwen3.5:9b       conf/tr   92.95    78.10  [74.85,81.25]  46.70  84.13  60.06  0.475   188
gemma3:27b        few/tr   93.20    79.45  [76.26,82.51]  47.90  90.48  62.64  0.560   549
qwen3.5:9b       zero/tr   93.70    79.53  [76.18,82.67]  50.00  83.33  62.50  0.365   136
qwen3.5:9b       zero/en   93.65    80.07  [76.88,83.18]  49.78  88.10  63.61  0.357   113
qwen3.5:9b        few/tr   94.35    80.75  [77.38,83.93]  53.37  81.75  64.58  0.290   584
qwen3.6:35b-a3b  zero/tr   94.65    81.56  [78.22,84.83]  55.03  82.54  66.03  0.353   136
qwen3.6:35b-a3b   few/tr   94.95    82.08  [78.62,85.31]  56.98  80.95  66.89  0.302   584

cP, cR ve cF1 şikâyet sınıfındaki precision, recall ve F1; s/doc belge başına sürenin medyanı (neden ortalama olmadığını kesişim kısmı açıklıyor). Satır etiketleri prompt ayarını ve talimatın dilini veriyor: zero hiç örnek vermeyen zero-shot prompt, few sekiz etiketli örnek içeren few-shot prompt, conf ise etiketin yanında bir güven değeri de isteyen prompt; /tr ve /en talimatın Türkçe mi İngilizce mi yazıldığını gösteriyor.

Bulgulardan önce adı konması gereken iki sınır. Prompt tasarımını başlı başına ciddi bir konu olarak prompting bölümü (Bölüm 17) ele alıyor; bu kısım yalnızca promptlamanın eğitilmiş bir alternatifle kıyaslandığında kaç puan aldığını soruyor, nasıl daha iyi prompt yazılacağını değil. İkincisi, kod çözme bölümü (Bölüm 18) “modelden ayrıştırılabilir bir cevap almak” işini kendi başına bir problem olarak ele alıyor; bir önceki alt bölümün de gösterdiği gibi, bu gerçekten de ciddi bir problem.

Aşağıdaki widget aynı tablonun sıralanmış ve çizdirilmiş hâli. Gösterdiği her şey yukarıdaki blokta var, dolayısıyla buradaki hiçbir şey widget’ı koşturabilmenize bağlı değil.

llmRows = [
  {tag: "llama3.2:3b zero/tr", model: "llama3.2:3b", cond: "zero", lang: "tr",
   acc: 66.35, mf1: 52.32, lo: 50.10, hi: 54.68, cp: 15.34, cr: 96.03, cf1: 26.45, secs: 0.121, ptok: 140},
  {tag: "llama3.2:3b zero/en", model: "llama3.2:3b", cond: "zero", lang: "en",
   acc: 87.80, mf1: 69.21, lo: 65.98, hi: 72.38, cp: 31.56, cr: 80.16, cf1: 45.29, secs: 0.124, ptok: 123},
  {tag: "gemma3:27b zero/tr", model: "gemma3:27b", cond: "zero", lang: "tr",
   acc: 88.65, mf1: 72.28, lo: 69.18, hi: 75.28, cp: 35.01, cr: 93.65, cf1: 50.97, secs: 0.592, ptok: 124},
  {tag: "qwen3.5:9b conf/tr", model: "qwen3.5:9b", cond: "conf", lang: "tr",
   acc: 92.95, mf1: 78.10, lo: 74.85, hi: 81.25, cp: 46.70, cr: 84.13, cf1: 60.06, secs: 0.475, ptok: 188},
  {tag: "gemma3:27b few/tr", model: "gemma3:27b", cond: "few", lang: "tr",
   acc: 93.20, mf1: 79.45, lo: 76.26, hi: 82.51, cp: 47.90, cr: 90.48, cf1: 62.64, secs: 0.560, ptok: 549},
  {tag: "qwen3.5:9b zero/tr", model: "qwen3.5:9b", cond: "zero", lang: "tr",
   acc: 93.70, mf1: 79.53, lo: 76.18, hi: 82.67, cp: 50.00, cr: 83.33, cf1: 62.50, secs: 0.365, ptok: 136},
  {tag: "qwen3.5:9b zero/en", model: "qwen3.5:9b", cond: "zero", lang: "en",
   acc: 93.65, mf1: 80.07, lo: 76.88, hi: 83.18, cp: 49.78, cr: 88.10, cf1: 63.61, secs: 0.357, ptok: 113},
  {tag: "qwen3.5:9b few/tr", model: "qwen3.5:9b", cond: "few", lang: "tr",
   acc: 94.35, mf1: 80.75, lo: 77.38, hi: 83.93, cp: 53.37, cr: 81.75, cf1: 64.58, secs: 0.290, ptok: 584},
  {tag: "qwen3.6:35b-a3b zero/tr", model: "qwen3.6:35b-a3b", cond: "zero", lang: "tr",
   acc: 94.65, mf1: 81.56, lo: 78.22, hi: 84.83, cp: 55.03, cr: 82.54, cf1: 66.03, secs: 0.353, ptok: 136},
  {tag: "qwen3.6:35b-a3b few/tr", model: "qwen3.6:35b-a3b", cond: "few", lang: "tr",
   acc: 94.95, mf1: 82.08, lo: 78.62, hi: 85.31, cp: 56.98, cr: 80.95, cf1: 66.89, secs: 0.302, ptok: 584}
]

viewof llmMetric = Inputs.radio(
  new Map([
    ["Macro-F1, bootstrap aralığıyla", "mf1"],
    ["Şikâyet F1 — yalnızca azınlık sınıfı", "cf1"],
    ["Şikâyet precision ve recall, ayrı ayrı", "pr"]
  ]),
  { value: "mf1", label: "" }
)

llmPlot = {
  const refs = [
    {label: "BERTurk, 40.000 etiket", mf1: 86.81, cf1: 75.29, colour: "#1F4E79"},
    {label: "BERTurk, 2.000 etiket",  mf1: 82.00, cf1: 66.09, colour: "#2E7D6F"},
    {label: "tf-idf, eşik kaydırılmış", mf1: 80.23, cf1: 62.90, colour: "#B3453E"},
    {label: "hep “memnun”",            mf1: 48.37, cf1: 0.00,  colour: "currentColor"}
  ];
  const order = llmRows.map(d => d.tag);
  if (llmMetric === "pr") {
    const long = llmRows.flatMap(d => [
      {tag: d.tag, kind: "precision", v: d.cp},
      {tag: d.tag, kind: "recall", v: d.cr}
    ]);
    return Plot.plot({
      width: 700, height: 400, marginLeft: 175, marginBottom: 46,
      x: {label: "şikâyet sınıfında yüzde", domain: [0, 100], grid: true},
      y: {label: null, domain: order},
      color: {domain: ["precision", "recall"], range: ["#1F4E79", "#B3453E"], legend: true},
      marks: [
        Plot.ruleX([74.42], {stroke: "#1F4E79", strokeDasharray: "4 3", strokeOpacity: 0.7}),
        Plot.ruleX([76.19], {stroke: "#B3453E", strokeDasharray: "4 3", strokeOpacity: 0.7}),
        Plot.dot(long, {y: "tag", x: "v", fill: "kind", r: 5,
          title: d => `${d.tag}\nşikâyet ${d.kind}: ${d.v.toFixed(2)}%`}),
        Plot.ruleY(llmRows, {y: "tag", x1: "cp", x2: "cr", stroke: "currentColor", strokeWidth: 1})
      ]
    });
  }
  const key = llmMetric;
  return Plot.plot({
    width: 700, height: 400, marginLeft: 175, marginBottom: 46,
    x: {label: key === "mf1" ? "2.000 belgelik altörneklemde macro-F1"
                             : "2.000 belgelik altörneklemde şikâyet F1",
        domain: [0, 100], grid: true},
    y: {label: null, domain: order},
    marks: [
      ...refs.map(r => Plot.ruleX([r[key]], {stroke: r.colour, strokeDasharray: "4 3", strokeOpacity: 0.8})),
      ...refs.map(r => Plot.text([{y: order[0], x: r[key]}], {
        y: "y", x: "x", text: [r.label], dy: -14, dx: 3, rotate: 0,
        fill: r.colour, textAnchor: "start", fontSize: 9})),
      key === "mf1"
        ? Plot.ruleY(llmRows, {y: "tag", x1: "lo", x2: "hi", stroke: "currentColor", strokeWidth: 6, strokeOpacity: 0.35})
        : null,
      Plot.dot(llmRows, {y: "tag", x: key, fill: "#0E7C7B", r: 5,
        title: d => `${d.tag}\nmacro-F1 ${d.mf1.toFixed(2)} [${d.lo.toFixed(2)}, ${d.hi.toFixed(2)}]`
                  + `\nşikâyet P ${d.cp.toFixed(1)} R ${d.cr.toFixed(1)} F1 ${d.cf1.toFixed(2)}`
                  + `\nbelge başına ${d.secs.toFixed(3)}s (medyan)`}),
      Plot.text(llmRows, {y: "tag", x: key, text: d => d[key].toFixed(2),
        dx: 9, textAnchor: "start", fontSize: 10, fontWeight: 600})
    ].filter(d => d)
  });
}

Şikâyet precision ve recall’a geçin. İki noktayı birleştiren gri çubuk aralarındaki farkı gösteriyor ve istisnasız her koşu aynı yöne eğiliyor: recall yüksek, precision düşük. İki kesik çizgi 40.000 etiketli BERTurk’ün değerleri (74,42 precision, 76,19 recall); grafikte iki noktası neredeyse üst üste binen tek model de o.

Üç bulgu; her biri, yukarıdaki aralıkların çakışıp çakışmadığına göz kararı bakarak değil, özdeş 2.000 belge üzerinde eşleştirilmiş bir bootstrap ile sınandı. Çakışan aralıklar bir test değildir: aynı belgeler üzerinde puanlanan iki model örneklem gürültüsünün büyük kısmını paylaşır ve marjinal aralıklar fazlasıyla çakışırken fark anlamlı olabilir. Aşağıdaki her \(p\), farkın 10.000 eşleştirilmiş yeniden örneklemesinden geliyor.

12.8.3.1 Prompt’u İngilizce yazmak işe yarıyor — model zayıfsa

                        tr       en      difference        p
llama3.2:3b           52.32    69.21   +16.90 [+14.59, +19.13]   0.0000
qwen3.5:9b            79.53    80.07    +0.54 [ -1.14,  +2.25]   0.5382

Yaygın kanı şöyle der: veri Türkçe olsa bile talimatı İngilizce yaz. 3B’lik modelde bunun kazancı +16,90 macro-F1 ve bir ölçümün olabileceği kadar tartışmasız. 9B’lik modelde aynı değişiklik +0,54 puan, \([-1{,}14, +2{,}25]\) — ki bu, etkinin ortadan kalktığının gösterimi değil. Eğer bir etki kaldıysa onun yaklaşık iki buçuk macro-F1 puanından küçük olduğunun gösterimi. Bu yararlı bir üst sınır ve “gürültü”den daha zayıf bir ifade. Ayrım da önemli, çünkü aynı tasarım iki puanlık gerçek bir kazancı da ayırt edemezdi.

llama3.2:3b üzerindeki Türkçe talimat başarısızlığı ince bir bozulma değil. Şikâyetlerin %96,03’ünü doğru etiketliyor ve bunu yaparken %15,34 precision’a ulaşıyor — yani gerçek oran %6,3 iken belgelerin kabaca %40’ına şikâyet diyor. İngilizce talimat ona Türkçe öğretmiyor; bu aşırı işaretlemeyi yaklaşık %16’ya indiriyor.

“İngilizce prompt kullan” tavsiyesinin ayakta kalmasının sebebi bu. İnsanların ilk denediği modellerde doğruydu ve yukarıdaki 3B gibi küçük modellerde hâlâ doğru; ama bugün kullanılan güçlü modellerde pek bir şey kazandırmaz olduktan çok sonra bile tekrarlanıyor. Kontrolün maliyeti fazladan bir koşu. LLM’lerle ilgili tavsiyelerin raf ömrü model kuşaklarıyla ölçülür ve bir kuralın hâlâ geçerli olup olmadığını bilmenin tek yolu, gerçekten kullanacağınız model üzerinde bir saat harcayıp yeniden ölçmek.

12.8.3.2 Sekiz örnek işe yarıyor — model zayıfsa

                       zero      few     difference        p
gemma3:27b            72.28    79.45    +7.17 [ +5.35,  +9.04]   0.0000
qwen3.5:9b            79.53    80.75    +1.22 [ -1.15,  +3.60]   0.3222
qwen3.6:35b-a3b       81.56    82.08    +0.51 [ -1.51,  +2.48]   0.6164

Dil sonucuyla aynı şekil. 8 etiketli örnekle in-context learning — her sınıftan dört tane, hiçbir test belgesi hiçbir prompt’a girmesin diye fit’ten çekilmiş — gemma3:27b’yi 7,17 puan oynatıyor, iki qwen3 modelini ise aralıklarının sıfırdan ayıramadığı miktarlarda. Bunları da dil sonucuyla aynı şekilde okuyun: qwen3.6:35b-a3b’nin \(+0{,}51\)’lik farkının aralığı \([-1{,}51, +2{,}48]\); yani koşunun ortaya koyduğu şey bir kazancın yokluğu değil, yaklaşık iki buçuk puanlık bir tavan.

in-context learning (bağlam içi öğrenme) — bir görevi, prompt’un içine yerleştirilmiş örneklerden öğrenmek. Hiçbir ağırlık güncellenmez ve çağrıdan geriye hiçbir şey kalmaz: sınıflandırdığınız her belge için aynı sekiz örnek yeniden gönderilir, yeniden okunur ve yeniden faturalanır. Maliyet yapısı budur ve fine-tuning’in tam tersidir; fine-tuning bir kez öder, sonra ucuza servis eder. ↩︎

İki pratik not. Birincisi, o 8 örnek 136’ya karşı 584 prompt token’ına mal oluyor; yani sonsuza kadar, belgelerinizin her birinde 4,3× daha büyük bir prompt. İkincisi, örneklerin sırası ve seçimi başlı başına bir varyans kaynağı ve etkiyi gölgede bırakacak kadar büyük. Zhao ve arkadaşları, aynı görevde ve aynı sayıda örnekle, yalnızca örneklerin sırası değiştiğinde doğruluğun şans düzeyine yakın bir değerden neredeyse en iyi bilinen sonuca kadar oynadığını gösterdi (Zhao vd. 2021). Biz sabit seed’le yapılmış tek bir seçim kullandık; dolayısıyla gemma3:27b üzerindeki +7,17’yi, örnek eklemenin beklenen değeri olarak değil, o dağılımdan tek bir çekiliş olarak okuyun.

12.8.3.3 Buradaki her promptlu koşu recall’a yatkındı ve bunu düzeltecek bir eşik yok

Bu, operasyonel sonucu en ağır olan bulgu ve yukarıdaki widget’ta şikâyet precision ve recall seçeneğinde görünüyor:

                              complaint P    complaint R
llama3.2:3b zero/tr              15.34          96.03
gemma3:27b zero/tr               35.01          93.65
qwen3.5:9b zero/tr               50.00          83.33
qwen3.6:35b-a3b few/tr           56.98          80.95
BERTurk, 40,000 labels           74.42          76.19

Promptlu her koşu olması gerekenden çok daha fazla belgeyi şikâyet olarak işaretliyor. En iyisi %80,95 recall’da %56,98 precision’a ulaşıyor; BERTurk ise 74,42 ve 76,19’da, neredeyse dengeli. Bir modele “bu bir şikâyet mi?” diye sorduğunuzda gereğinden sık evet diyor.

Sorun çalışma noktasının yanlış olması değil. Sorun kaydırılacak bir çalışma noktasının olmaması. Bölüm 12.5 bu sorunun ayna görüntüsünü — 0,5’te şikâyetlerin çok azını işaretleyen doğrusal bir modeli — tek bir eşiği kaydırarak düzeltmiş ve hiçbir bedel ödemeden 19,42 macro-F1 puanı kazanmıştı. O alet burada yok. Zero-shot bir model bir sayı değil, ŞİKAYET kelimesini döndürüyor ve bir kelimeye eşik uygulayamazsınız.

Bu bölümün bir puanın üzerine kurduğu her şey de onunla birlikte gidiyor: ROC eğrisi yok, PR eğrisi yok, izotonik kalibrasyon yok, bir maliyet oranından gelen \(q^*\) yok, maliyeti en aza indiren tarama yok. Bir kısmını geri kazanabilirsiniz. Servis yazılımınız sunuyorsa, modelin iki aday cevap kelimesine (ŞİKAYET ve MEMNUN) verdiği log-olasılıkları okuyabilirsiniz; bu, kelimeyi yeniden bir puana çevirir. Ya da bir sonraki alt bölümde yapıldığı gibi, modelden güvenini kelimelerle belirtmesini isteyebilirsiniz. Ama varsayılan hâlde, promptlu bir model seçmek eşikten vazgeçmeyi seçmektir.

Bu bulgunun bir sınırı: modelleri bundan vazgeçirmeye çalışmadık. “ŞİKAYET cevabını yalnızca yorumcu somut bir kusur belirtiyorsa ver” diyen bir prompt çalışma noktasını muhtemelen kaydırırdı ve biz bunu ölçmedik. Hiçbir prompt’un size vermediği şey bir kadran — maliyet oranı değiştiğinde ve aynı eğri üzerinde farklı bir noktaya ihtiyacınız olduğunda, yayına aldıktan sonra çevirebileceğiniz bir düğme.

12.8.3.4 Modelin yazdığı bir güven, olasılık mıdır?

conf koşulu qwen3.5:9b’den ETİKET|GÜVEN biçiminde, 0–100 arası bir tam sayı istedi. 2.000 cevabın hepsi ayrıştırılabildi. Buna verbalised confidence (sözel güven) denir ve zero-shot ayarın sunabildiği, puana en yakın şey budur.

verbalised confidence (sözel güven) — modelin puanlarından okunan bir olasılık değil, modelin metin olarak yazdığı bir sayı. Bölüm 12.6 başka her güveni nasıl yargılıyorsa onu da öyle yargılayın: haklı çıkma sıklığıyla örtüşüyor mu ve doğruyu yanlıştan ayırıyor mu? ↩︎

stated confidence      n      actually right
     50                3          100.0%
     60                1          100.0%
     70                1          100.0%
     75               62           80.6%
     85               25           76.0%
     90              286           83.2%
     92               23           82.6%
     95            1,549           95.4%
    100               50          100.0%

mean stated confidence  93.53      overall accuracy  92.95      gap  +0.58
expected calibration error (over stated values)                 1.80

İnsanların fiilen raporladığı testte — ortalama beyan edilen güven, ortalama doğrulukla örtüşüyor mu? — sonuç dikkat çekici derecede iyi. Ortalama beyan edilen güven %93,53 ve model, tahminlerinin %92,95’inde haklı; aradaki fark +0,58 puan. Dokuz beyan değeri üzerinden kutucuklara ayrıldığında ECE 1,80 çıkıyor; sınıf ağırlıklı tf-idf modelinde bu değer 8,98. Bu karşılaştırmayı yalnızca kabaca yorumlayın: kalibrasyon kısmının (Bölüm 12.6) ısrarla belirttiği gibi, bir ECE değeri kutulama şeması olmadan hiçbir şey ifade etmez ve buradaki, on beş eşit genişlikli kutucuk değil, modelin seçtiği dokuz kutucuk kullanıyor. Büyüklük mertebesi doğru, ama birebir karşılaştırılabilir bir sayı değil. Lin ve arkadaşları bir modelin belirsizliği kelimelerle kalibre biçimde ifade etmek üzere eğitilebileceğini gösterdi (Lin vd. 2022); bu görevde model, hiçbir ek eğitim olmadan zaten öyle yapıyor.

Sonra ikinci sütuna bakın. 2.000 belgenin 1.549’u — %77,45’i — aynı sayıyı, 95’i aldı. Koşunun tamamında 9 farklı değer var. Neredeyse hep 95 olan bir güven, hangi belgelerin bir insana yönlendirileceği konusunda size fazla bir şey söyleyemez.

Kendi hatalarının dedektörü olarak ölçüldüğünde beyan edilen güven 0,667’lik bir AUROC alıyor. BERTurk’ün kendi en üst etiket olasılığı, aynı 2.000 belge üzerinde, 1.325 farklı değer boyunca 0,843 alıyor. İki model de kendi hatalarını bir ölçüde işaretleyebiliyor; eğitilmiş olan bunu daha iyi yapıyor ve size bir anahtar değil bir kadran veriyor.

O farkı bir çekinceyle okuyun, çünkü bölüm bunun sebebini daha önce söyledi ama sonucunu çıkarmadı. AUROC beraberliklere yarım puan verir ve LLM’in belgelerinin %77,45’i tek bir güven değerini paylaşıyor — yani tüm belge çiftlerinin kabaca beşte üçü onun için beraberlik. AUROC’un gerçekten karşılaştırdığı çiftlerin, yani bir doğru cevapla bir yanlış cevabın oluşturduğu çiftlerin %45’i beraberlik; 1.325 farklı değeri olan BERTurk’te ise neredeyse hiçbiri. 0,667 ile 0,843 arasındaki farkın bir kısmı daha kötü bir sinyalden, bir kısmı ise daha kaba bir sinyalden kaynaklanıyor ve bu karşılaştırma ikisini birbirinden ayırmıyor. Pratik sonuç her hâlükârda aynı — dokuz değer size bir anahtar, 1.325 değer bir kadran verir — ama farkı “LLM’in güveni 0,18 AUROC daha kötü” diye okumayın.

Yine de tek işe yarar ayrım gerçek: beyan edilen güven ≥ 95 olduğunda model, bu tahminlerin %95,56’sında haklı (n = 1.599), 95’in altında ise %82,54’ünde (n = 401). İş akışınızın tek ihtiyacı “bunların beşte birini bir insana gönder” ise, bu üzerine bir şey kurmak için yeterli — bölümün geri kalanının ısrar edeceği çekinceyle birlikte. 95’i o tabloya bakarak seçtik ve o tablo değerlendirme kümesi. Kurulumda konan kurala göre (Bölüm 12.1), 82,54’e karşı 95,56 bu yüzden bir oracle bölmesi ve bir üst sınır, bir sonuç değil. Kesme noktasını, üzerinden bir şey yönlendirmeden önce ayrılmış belgelerde seçin.

Xiong ve arkadaşları kara kutu güven sorgulamayı (confidence elicitation) modeller ve görevler boyunca değerlendirdi ve 0,522–0,605 bandında AUROC’lar raporladı; buna, modellerin insanların kesinliği ifade ediş biçimini taklit etmesine bağladıkları sistematik bir aşırı güven eğilimi eşlik ediyor (Xiong vd. 2024). Bizim 0,667’miz onların aralığının biraz üstünde ve ortalama farkımız küçük — ama tek bir değerde %77,5’lik yığılma, tam da tarif ettikleri başarısızlık kipi. Bir güven, ortalamada doğru olup neredeyse hiçbir şeyi ayırmıyor olabilir.

12.9 Küçük model mi, LLM mi: kesişim

Şimdi karar. Önceki iki kısım aynı 2.000 belge üzerinde birer sayı üretti, dolayısıyla nihayet doğrudan karşılaştırılabilirler. Kararı iki eksen veriyor ve hiçbiri kaliteye karşı kalite değil: kaç etiketiniz var ve bir belgeyi sınıflandırmak neye mal oluyor.

12.9.1 Encoder–LLM kesişimi 2.000 etikette ve bir galibiyet değil, bir beraberlik

Peki iki eğri nerede buluşuyor? Bunu cevaplamanın yolu iki nokta tahminini karşılaştırmak değil, çünkü birbirinden farklı iki sayı, üzerine gürültü binmiş aynı sayı olabilir. İki sistem de aynı belgeler üzerinde çalıştı; dolayısıyla onları eşleştirip fark üzerinde doğrudan bootstrap uygulayabiliriz.

paired bootstrap, same 2,000 documents, 10,000 resamples

BERTurk  1,000 labels  vs  qwen3.6:35b-a3b zero-shot    -8.79 [-13.53,  -4.24]   p = 0.0002
BERTurk  2,000 labels  vs  qwen3.6:35b-a3b zero-shot    +0.43 [ -3.17,  +3.85]   p = 0.8030
BERTurk  2,000 labels  vs  qwen3.6:35b-a3b 8-shot       -0.08 [ -3.78,  +3.61]   p = 0.9728
BERTurk 40,000 labels  vs  qwen3.6:35b-a3b 8-shot       +4.73 [ +1.56,  +7.90]   p = 0.0028

2.000 etikette fine-tune edilmiş encoder ile en iyi promptlu model bu örneklem büyüklüğünde istatistiksel olarak ayırt edilemez. Bu, beraberlikten daha zayıf bir iddia ve ne kadar zayıf olduğunu aralık söylüyor. Altörneklemde 126 şikâyet olduğu için eşleştirilmiş standart hata 1,89 macro-F1 puanı; yani bu tasarım ancak yaklaşık 3,2 puandan büyük farkları dışlayabiliyor (%90’lık aralık \([-3{,}18, +3{,}02]\); bir eşdeğerlik testi de bu aralıkla çalışır) ve ancak 5,3 puanın üstündeki farkları %80 güçle yakalayabiliyor. 2.000 etiket satırını onları birbirinden ayırt edemedik diye okuyun, aynılar diye değil: mesela ±1 puanlık gerçek bir eşdeğerlik iddiası, bu sınıf dengesinde bunun yaklaşık on katı belge isterdi. Ayrıca dikkat edin: 40.000 etiketteki kendi +4,73’ümüz de o %80 güç eşiğinin altında — anlamlı çıktı, ama tasarım onu yakalayacağını garanti edecek biçimde kurulmamıştı.

1.000 etikette LLM 8,79 puanla kazanıyor ve sonuç yakın bile değil. 40.000’de encoder 4,73 puanla kazanıyor ve o sonuç da yakın değil.

Yani bu görevde kesişim kabaca 2.000 etiketli belgede duruyor ve bunu bir hüküm olarak değil, üç rejim olarak düşünmek daha faydalı — artı “promptla ya da fine-tune et” çerçevesinin gizlediği dördüncü bir seçenek:

• ~1.000 etiketin altı. Promptlayın. Encoder henüz şikâyetin ne olduğunu öğrenmemiş — 500 etikette bu altörneklemde 48,37’lik çoğunluk baseline’ına karşı 59,47 macro-F1 alıyor ve şikâyetlerin %14,29’unu yakalıyor — ve bir öğrenme oranı taramasının bunu değiştireceğini sanmıyoruz, ama ölçmedik. Farklı bir reçete değiştirebilir: setfit (Bölüm 12.13), bir cümle encoder’ının karşıtsal (contrastive) fine-tuning’i ile üzerine eklenen lojistik bir head’den oluşur. Tam da bu bütçe için tasarlanmıştır ve sınıf başına 8–64 örnekle kullanılabilir düzeyde macro-F1 raporlaması olağandır (Tunstall vd. 2022). Biz onu ölçmedik; 200, 500 ve 1.000 etikette çalıştırmak, bu maddeyi değiştirme ihtimali en yüksek tek ölçüm.
• 2.000 civarı. Kalite açısından gerçekten yazı tura. Kararı maliyet, gecikme, operasyonel denetim ve bir eşiğe ihtiyacınız olup olmadığı üzerinden verin. Dördü de aynı yönü gösteriyor; bir sonraki alt bölümün konusu bu.
• 2.000’in üstü. Fine-tune edin. Elimizde ölçülmüş tam olarak bir nokta daha var — 40.000’de encoder 4,73 puanla kazanıyor — dolayısıyla 2.000 ile 40.000 arasında farkın nerede belirleyici hâle geldiği bir ölçüm değil, encoder’ın kendi öğrenme eğrisinden yapılan bir ara değer kestirimi (interpolasyon). Ölçülmüş olan şey yön; bir de encoder’ın, ikisinden size bir puan veren tek taraf olduğu.
• Bu çerçevenin dışarıda bıraktığı seçenek. Promptlu modele sonsuza kadar ödemekle elle etiketlemek arasında seçim yapmak zorunda değilsiniz. Bu parayı bir kez harcayın: etiketsiz havuzunuzu büyük modelle etiketleyin, sonra encoder’ı o etiketlerle fine-tune edin — etiketleyici olarak LLM, öğrenci olarak encoder (Hsieh vd. 2023; Gilardi vd. 2023). Kendi sayılarımız bunun fiyatını veriyor: bin belge başına 352,6 saniyeyle 40.000 belgenin tamamını etiketlemek, dizüstü GPU’da dört saatten kısa sürer. Karşılığında aldığınız şey, bu zero-shot öğretmenden kabaca 165 kat ucuza servis eden ve Bölüm 12.8’in gösterdiği gibi promptlamanın elinizden aldığı puanı, ROC eğrisini ve eşiği size geri veren bir öğrenci. Etiketler gürültülü, dolayısıyla doğal karşılaştırma noktası bir insanınki değil öğretmenin 81,56’sı. Bir öğretmenin etiketleriyle eğitilen öğrenci öğretmenin altında da kalabilir, Hsieh vd.’nin (2023) bildirdiği gibi üstüne de çıkabilir; bu öğrencinin nereye düştüğü ise tam da yapmadığımız ölçüm — ve ilk yapacağımız ölçüm o olurdu.

Bu, literatürün çizdiği genel resimle çelişmiyor, onunla tutarlı. Edwards ve Camacho-Collados, 16 veri kümesinde tam eğitim verisiyle fine-tuning’i 0,119 micro-F1 önde buldu, ama one-shot rejimde promptlamayı açıkça önde buldu (Edwards ve Camacho-Collados 2024); Bucher ve Martini kesişimi kabaca 200 eğitim gözleminin üstüne koydu, gerçi modern bir talimat ayarlı modele karşı değil, zero-shot BART-large-MNLI’ye karşı (Bucher ve Martini 2024). Bizim kesişimimiz onlarınkinden bir büyüklük mertebesi yukarıda; promptlu model 2019 tarihli bir doğal dil çıkarımı (entailment) modeli değil de 2026 tarihli 36B’lik bir mixture-of-experts olduğunda beklenecek şey de bu. Kesişim, karşılaştırdığınız çiftin bir özelliğidir, bir sabit değil — bu da kesişimi, bizimki dâhil herhangi birinin sayısını alıntılamak yerine kendi göreviniz üzerinde ölçmenin gerekçesi.

12.9.2 Bir belge neye mal oluyor

Tartışma kaliteyle başlıyor. Genelde maliyetle bitiyor.

option                              docs/sec    seconds per 1,000 docs

tf-idf + LR, batched                  72,972              0.014
tf-idf + LR, one at a time             6,543              0.153
BERTurk fine-tuned, batched              470              2.128
llama3.2:3b  zero-shot, one at a time      8.3           121.0
qwen3.5:9b  8-shot, one at a time          3.4           289.9
qwen3.6:35b-a3b  8-shot, one at a time     3.3           301.5
qwen3.6:35b-a3b  zero-shot, one at a time  2.8           352.6
qwen3.5:9b  zero-shot, one at a time       2.7           365.0
gemma3:27b  8-shot, one at a time          1.8           559.8
gemma3:27b  zero-shot, one at a time       1.7           592.5

Sağdaki sütunu oran olarak okuyun: tartışma artık başa baş olmaktan çıkıyor. Bir milyon belgeyi sınıflandırmak seyrek modelle 14 saniye, fine-tune edilmiş encoder’la 35 dakika, en iyi promptlu modelle üç buçuk gün sürüyor. Encoder, 2.000 etikette berabere kaldığı promptlu modelden belge başına 142× daha ucuz; seyrek model ise kabaca 22.000× daha ucuz.

Bu oranın ne olduğu ve ne olmadığı üzerine iki not. Oran, batchlenmiş bir encoder’ı tek akışlı yerel bir sunucuyla karşılaştırıyor; küçük ekiplerin çoğunun fiilen karşılaştığı durum da bu. Promptlu taraf için en elverişli düzenleme bu değil. Tablodaki tf-idf çifti, batchlemenin tek başına 11× hız kazandırdığını gösteriyor (6.543’e karşı 72.972); batchlemeyi düzgün yapan, barındırılan (hosted) bir API de bu farkın iyi bir kısmını geri kazanırdı. Batchlemenin telafi edemeyeceği şey ise işin altında yatan mekanizma. Encoder belgeyi bir kez okuyup bir sayı çıkarıyor. Promptlu model ise cevabını token token yazmak zorunda; her token da etkin parametre sayısı bakımından otuz ila iki yüz elli kat daha büyük bir ağdan baştan sona bir geçiş demek. Batchleme ek yükü amorti eder; aritmetiği değiştirmez.

Tablodaki bir satır sizi duraksatmalı: 8-shot, karşılaştırılabildiği üç çiftin üçünde de zero-shot’tan hızlı — qwen3.6’da 352,6’ya karşı 301,5, qwen3.5’te 365,0’a karşı 289,9, gemma3’te 592,5’e karşı 559,8 — hem de prompt 4,3× daha uzun olduğu hâlde.

Bunun bir kısmının açıklaması basit. Gecikme, paralel işlenen prompt token’larını değil, teker teker üretilen çıktı token’larını izliyor. conf koşusu 4,1’e karşılık 7,1 token üretiyor ve beklendiği gibi en yavaş qwen3.5 koşulu oluyor.

Ama bu, işin tamamını açıklamıyor. qwen3.5’in zero ve few koşullarının ikisi de 4,1 token üretiyor; dolayısıyla çıktı uzunluğu bu çifti açıklayamaz.

Geriye kalan muhtemel açıklama, 8-shot ön ekinin 2.000 isteğin hepsinde özdeş olması ve sunucunun onu önbelleğe alması. Bunu ölçmedik, dolayısıyla iddia etmiyoruz — ve bu kadar gürültülü bir dizüstü bilgisayarda, farklı zamanlarda yapılmış iki koşu arasındaki %20’lik bir fark üzerine argüman kurulmaz.

Her LLM rakamı bir medyan ve bu seçim süs değil. qwen3.5:9b zero-shot koşusunun belge başına ortalaması 3,371 saniye, medyanı ise 0,365. Aradaki 9 katlık farkı takılan 18 belge üretiyor; en kötüsü 980 saniye takıldı. Bu takılmalar, modelin değil, bir süreliğine başka bir şey yapmaya karar vermiş bir dizüstü bilgisayarın özelliği. Ortalamayı raporlasaydık bu modelin maliyetini bir büyüklük mertebesi şişirmiş ve yukarıdaki karşılaştırmayı anlamsızlaştırmış olurduk — hem de modelin lehine değil, aleyhine.

Mixture-of-experts modelinin nereye düştüğüne dikkat edin. qwen3.6:35b-a3b’nin 36B parametresi var ama token başına yaklaşık 3B’sini etkinleştiriyor. Bir belgeyi 0,353s’de servis ediyor: yoğun 9,7B’lik modelin 0,365s’sinden daha hızlı, yoğun 27,4B’lik modelin 0,592s’sinden 1,7× hızlı. Üstelik ikisinden de yüksek puan alıyor. Mixture-of-experts argümanı (Bölüm 7.7) burada bir servis faturası olarak karşımıza çıkıyor: çıkarımda parasını ödediğiniz şey toplam parametreler değil, etkin parametrelerdir.

İkinci bir asimetri daha var ve ters yönde işliyor. Promptlu modeller her belge için sonsuza kadar ödüyor, encoder ise bir kez ödüyor. En iyi prompt’la berabere kalan 2.000 etiketli model 1.260 optimizasyon adımı, yani yaklaşık 6,5 dakika düzeltilmiş GPU zamanı demek; bu maliyet kabaca 1.300 belgeden sonra kendini amorti ediyor.

Ama 6,5 dakika GPU faturası ve maliyetin küçük olan yarısı. Encoder’ın ayrıca 2.000 etiketli belgeye ihtiyacı var; 8-shot prompt’un sekiz taneye. Bu bölüm sizin etiketlemenizi fiyatlandıramaz. Belge başına on saniye sürerse bu, birinin beş buçuk saatlik dikkati demek; belge başına bir dakika sürerse bir çalışma haftası. GPU faturası bir sabahta kapanır. Asıl maliyet etiketlerdir ve fine-tuning kısmının (Bölüm 12.3) etiketlemeye darboğaz demesinin sebebi de onlardır. Etiketlerin size kazandırdığı şey, bu karşılaştırmaya girebilme hakkı.

12.9.3 Karar, onu belirleyen iki eksen üzerinde

Bu kadar ölçüm yeter. Okurun gerçekten ihtiyaç duyduğu şey skor tablosu değil, kendi durumunu bu tablo üzerinde konumlandırmanın bir yolu. Etiket sayınızı ve belge hacminizi girin, sayıların hangi sistemi işaret ettiğini okuyun.

crossRows = [
  {name: "tf-idf + LR, eşik kaydırılmış", mf1: 80.23, s1k: 0.014, kind: "trained", labels: 40000},
  {name: "BERTurk, 1.000 etiket",     mf1: 72.78, s1k: 2.128, kind: "trained", labels: 1000},
  {name: "BERTurk, 2.000 etiket",     mf1: 82.00, s1k: 2.128, kind: "trained", labels: 2000},
  {name: "BERTurk, 40.000 etiket",    mf1: 86.81, s1k: 2.128, kind: "trained", labels: 40000},
  {name: "llama3.2:3b zero/tr",       mf1: 52.32, s1k: 121.0, kind: "llm", labels: 0},
  {name: "llama3.2:3b zero/en",       mf1: 69.21, s1k: 124.0, kind: "llm", labels: 0},
  {name: "qwen3.5:9b zero/tr",        mf1: 79.53, s1k: 365.0, kind: "llm", labels: 0},
  {name: "qwen3.5:9b few/tr",         mf1: 80.75, s1k: 289.9, kind: "llm", labels: 8},
  {name: "gemma3:27b zero/tr",        mf1: 72.28, s1k: 592.5, kind: "llm", labels: 0},
  {name: "gemma3:27b few/tr",         mf1: 79.45, s1k: 559.8, kind: "llm", labels: 8},
  {name: "qwen3.6:35b-a3b zero/tr",   mf1: 81.56, s1k: 352.6, kind: "llm", labels: 0},
  {name: "qwen3.6:35b-a3b few/tr",    mf1: 82.08, s1k: 301.5, kind: "llm", labels: 8}
]

crossPlot = Plot.plot({
  width: 700,
  height: 420,
  marginLeft: 62,
  marginBottom: 52,
  marginRight: 20,
  x: {label: "1.000 belgeyi sınıflandırma süresi, saniye  (log ölçek, düşük olan iyi)",
      type: "log", grid: true,
      ticks: [0.01, 0.1, 1, 10, 100, 1000],
      tickFormat: d => d < 1 ? String(d).replace(".", ",") : d.toLocaleString("tr-TR")},
  y: {label: "2.000 belgelik altörneklemde macro-F1", domain: [40, 95], grid: true},
  color: {domain: ["trained", "llm"],
          range: ["#1F4E79", "#B3453E"],
          legend: true,
          tickFormat: d => ({trained: "etiketlerle eğitilmiş",
                             llm: "promptlu, eğitimsiz"})[d]},
  marks: [
    Plot.ruleY([48.37], {stroke: "currentColor", strokeDasharray: "4 3"}),
    Plot.text([{x: 0.02, y: 48.37}], {x: "x", y: "y", text: ["hep “memnun” — 48,37"],
      dy: -8, fill: "currentColor", textAnchor: "start", fontSize: 9}),
    Plot.dot(crossRows, {x: "s1k", y: "mf1", fill: "kind", r: 6,
      title: d => `${d.name}\nmacro-F1 ${d.mf1.toFixed(2)}\n1.000 belge başına ${d.s1k}s`
                + `\n${d.labels.toLocaleString("tr-TR")} etiket kullanıldı`}),
    Plot.text(crossRows, {x: "s1k", y: "mf1", text: "name", dy: -12,
      fontSize: 9, textAnchor: "middle"})
  ]
})

Aşağı ve sağa gitmek iki eksende birden kötü. Eğitilmiş olan her şey grafiğin sol yarısında, iki ila dört büyüklük mertebesi farkla; promptlu olan her şey sağda. En iyi promptlu model (82,08) ile 2.000 etiketli BERTurk (82,00) aynı yükseklikte ve yatayda 142× uzakta — bu kısmın bütün argümanı, tek bir nokta çiftinde. Her noktanın iki koordinatı da yukarıdaki iki çıktı tablosunda var, dolayısıyla grafik bilgi değil kolaylık ekliyor.

12.9.4 İki model farklı belgelerde başarısız oluyor

Bölüm 12.10 tf-idf ile BERTurk’ü belge belge çapraz tablolayacak ve farklı belgeleri ıskaladıklarını bulacak; bu örtüşmeme, iki modeli birleştirmenin işe yarayabileceği koşul. İşte aynı çapraz tablo; bu kez paylaşılan 2.000 belge üzerinde, qwen3.6:35b-a3b 8-shot ile 40.000 etiketli BERTurk arasında. Satırlar LLM’in, sütunlar BERTurk’ün doğru ya da yanlış olduğu belgeleri sayıyor; alttaki satırlar anlaşma oranını ve her belgede iki modelden iyisini seçen bir oracle’ın puanını veriyor:

                          BERTurk right    BERTurk wrong
LLM right                     1,871              28
LLM wrong                        66              35

they agree on 95.30% of documents
an oracle picking the better of the two per document: 92.62 macro-F1
BERTurk alone:                                       86.81

Sağ üst köşedeki 28 belge gerçek: fine-tune edilmiş encoder’ın yanlış, promptlu modelin doğru yaptığı vakalar. Her seferinde kazananı seçebilen bir oracle, BERTurk’ün 86,81’ine karşı 92,62 alırdı — ortada duran 5,81 puan.

Bunu yayına almıyoruz. Sebebi bir dipnot değil, bu kısmın asıl konusu. O 28 belgeyi yakalamak için belgeleri LLM’e göndermek zorundasınız ve LLM belge başına 142× pahalı. Her şeyi BERTurk’le puanlayıp trafiğin %10’unu bile promptlu modele ileten bir yönlendirici 1.000 belgeyi 2,1 saniye yerine 32,3 saniyede işliyor — 2.000 belgedeki 28 belgeyi kovalamak için 15× servis faturası. 5,81 puan gerçek, ama bu puanları toplayacak mekanizmanın bedeli karşılanamaz. Çoğu topluluk (ensemble) fırsatı böyledir: çevrimdışı bir çapraz tabloda görünür, maliyet sütununda silinir.

Karşılığını veren sürüm, yukarıdaki güven ölçümünün işaret ettiği sürüm. Ucuz modelin verdiği puan, kendi hatalarını 0,843 AUROC ile ayırt ediyor. Bu puanı kullanarak belirsiz kuyruğu daha büyük bir modele değil, bir insana yönlendirin. Bu, maliyet matrisi kısmındaki düzeneğin (Bölüm 12.7) farklı bir karara uygulanmış hâli ve ikinci bir modele hiç ihtiyaç duymuyor.

12.10 Bir disiplin olarak hata analizi

Buraya kadarki her sayı size modelin ne sıklıkla yanıldığını söylüyor. Hiçbiri ne konuda yanıldığını söylemiyor; oysa yayına alıp almayacağınıza karar veren soru bu. Bu kısmın konusu bir alışkanlık: metriklerden sonra hataları okuyun.

İki eğitilmiş modeli, zaten seçilmiş çalışma noktalarında karşılaştırıyoruz — tf-idf şikâyet tarafında \(t = 0{,}166\)’da ve 40.000 etiketli BERTurk \(0{,}5\)’te okunmuş hâlde. 10.000 belgelik test kümesinde bu, tf-idf için 632 şikâyetin 373’ünün, BERTurk için 452’sinin yakalanması demek; sırasıyla %57,38 ve %72,32 precision’la.

12.10.1 Çoğu zaman kurulmayan ama kurulması gereken 2×2

Bu iki çalışma noktasında toplam fark 7,35 macro-F1 puanı — yeniden eşiklenmiş tf-idf + LR’nin 77,66’sına karşı BERTurk’ün 85,02’si — ve o tek sayı bir ödünleşimi gizliyor. Ödünleşimi görmenin tek yolu iki modeli belge belge çapraz tablolamak.

Model değiştirmek bir ödünleşim, bir yükseltme değil

Öne çıkarılan 7,35 puan net bir rakam. Model değiştirmek 332 belgeyi düzeltiyor, 149’unu bozuyor — gerçek bir kazanç, ama brüt kazancın %45’i geri veriliyor (149/332); geriye net 183 kalıyor. O 149 belge sizin en değerli vakalarınızsa, toplam sayı size yalan söylüyor demektir.

O ızgaradan, liderlik tablosunun size gösteremeyeceği üç şey çıkıyor.

Kazanç göründüğünden küçük ve bir ödünleşim. 332 belge düzeliyor; tf-idf’in doğru sınıflandırdığı 149 belge ise bozuluyor. 7,35 puanlık bir iyileşme raporlamak yalan değil, ama aynı rapor 149 belgenin bozulduğunu size söylemiyor. Şikâyetleriniz bir insan kuyruğuna gidiyorsa ve bu kuyruk tam da o 149 belgeye göre ayarlanmışsa, “yükseltme” o ekip için bir gerileme olur.

Aşılamayan bir hata tabanı var ve yüksek. 204 belgede iki model de yanılıyor ve bunların 137’si şikâyet — test kümesindeki tüm şikâyetlerin %21,7’sini ne seyrek doğrusal model ne de fine-tune edilmiş transformer yakalayabiliyor. Bu, daha büyük bir encoder’la çözeceğiniz bir kapasite sorunu değil. Ya gerçekten belirsiz metin ya da bozuk bir etiket; sonraki iki alt bölüm ağırlıkla ikincisi olduğunu savunuyor.

İki model farklı şeylerde başarısız oluyor. 685 belgeyi iki modelden en az biri ıskalıyor ve bunların yalnızca 204’ünü ikisi birden ıskalıyor; kalan 481’de modeller anlaşamıyor. Bu örtüşmeme, bir topluluğun (ensemble) işe yaradığı koşul — ve burada daha faydalısı, anlaşmazlıkları okumanın size bir şey öğrettiği koşul, çünkü her modelin hataları belli bir örüntü izliyor.

Anlaşmazlık 2×2’si tek satırlık kod ve beş saniye demek: pd.crosstab(pred_a == y, pred_b == y). Üretimde bir modeli her değiştirdiğinizde bu tabloyu kurun. Tablonun en önemli hâli ise bu değil, önemsediğiniz sınıfla sınırlandırılmış olanı: 122 şikâyet kazanıldı, 43 şikâyet kaybedildi.

12.10.2 Sonuca varmadan önce dilimleyin

İkinci ucuz alışkanlık: test kümesini etiketleme gerektirmeden ölçebileceğiniz herhangi bir şeye göre bölün ve genel sonucun her dilimin içinde de geçerli olup olmadığına bakın. Belge uzunluğunu ölçmenin hiçbir maliyeti yok.

length (chars)      n    complaints   tf-idf err   BERTurk err   ratio
<50             1,644         6.14%        5.29%         4.50%    1.18
50–99           2,253         6.39%        5.77%         3.99%    1.44
100–199         3,499         6.09%        4.86%         3.12%    1.56
200–399         2,096         7.16%        5.82%         3.10%    1.88
400+              508         4.72%        5.31%         2.95%    1.80

tf-idf’in hata oranı düz. Hiçbir eğilim göstermeden %4,86 ile %5,82 arasında geziniyor — daha uzun bir yorum, kelime torbası modeline daha fazla kelime verir, ama aynı zamanda neşeli bir kelimenin şikâyeti oy çokluğuyla bastırması için daha fazla şans verir. BERTurk’ün hata oranı ise neredeyse monoton düşüyor: 50 karakterin altındaki yorumlarda %4,50’den 200–399 karakterlik yorumlarda %3,10’a. Üstünlük en kısa belgelerde 1,18×, en uzun ikinci dilimde 1,88×.

Kesin bir dille söylersek, encoder’ın asıl satış argümanı bu: her yerde daha iyi değil, uzun belgelerde daha iyi; çünkü olumsuzlama, ödünleme yapıları (concessive: “-se de”, “rağmen”) ve kapsam (scope) ilişkileri uzun belgelerde ortaya çıkıyor ve bir kelime torbası modelinin bunların hiçbiri hakkında söyleyecek sözü yok. Üretim trafiğiniz ağırlıkla tek satırlık yorumlardan oluşuyorsa, hesabınızı 1,88×’e göre değil 1,18×’e göre yapmalısınız.

400+ satırını şüpheyle okuyun. Bu satırda 508 belge ve kabaca 24 şikâyet var; dolayısıyla BERTurk’ün %2,95’i yaklaşık 15 hata demek. Tek bir belge bu oranı 0,2 puan oynatıyor. Bulgu, ilk dört dilimdeki eğilim; son satır onunla tutarlı, onun kanıtı değil.

12.10.3 Hataları rastgele değil, güvene göre sıralayın

Rastgele bir hata örneklemi okumak size çoğunlukla zor vakaların zor olduğunu öğretir. Bilgi, modelin en emin olduğu hataları okumakta, çünkü etiketleri gürültülü bir derlemde kendinden emin biçimde yanılan bir model çoğu zaman haklı olduğu için cezalandırılıyordur.

İşte BERTurk’ün en emin olduğu hatalar. Yorumlar, arşiv kaydındaki İngilizce çevirileriyle veriliyor; sayılar, modelin şikâyet tarafı için verdiği olasılıklar.

gold        p(complaint)   review (glossed)
complaint         0.0011   "I chose it because the price was right, but I was
                            very pleased once I used it … definitely worth it."
complaint         0.0012   "Thank you so much, prettier than the picture, I
                            loved it, an anniversary gift for my wife :-)"
satisfied         0.9988   "It broke within two months and became unusable
                            (I'm giving five stars so my review shows up at the
                            top, normally it doesn't deserve a star)"
satisfied         0.9986   "The suction was weak and it burned out after 5–6
                            months."
satisfied         0.9986   "Friends, it does nothing for belly fat, that's
                            certain … so if you're buying it for your belly,
                            don't."
satisfied         0.9988   "You'll regret it if you don't buy it."
satisfied         0.9987   "A so-so product."

Üçüncü satır hakemliğe hiç ihtiyaç duymayan satır. Yorumcu, yorumun içinde, yıldız puanının değerlendirici değil stratejik olduğunu belirtiyor — şikâyet listenin başına çıksın diye beş yıldız. Derlemin veri kartı etiketlerin nasıl türetildiğini belgelemiyor (Bölüm 4); ama bu satır, yıldız puanlarından türetildiklerinin güçlü bir kanıtı. Yani etiket yıldızları doğru, duyguyu ise yanlış kaydediyor. Yorumcu da referans etiketimizin hangi mekanizmayla bozulduğunu bize nazikçe belgelemiş.

Altındaki iki satır da bize göre aynı durumda: yanan bir süpürge ve ürünün “hiçbir işe yaramadığını” söyleyip almayın diye biten bir yorum — ikisi de memnun olarak etiketlenmiş. Üstündeki iki satır ise ters yönde: şikâyet olarak etiketlenmiş iki övgü dolu yorum. Bunu bir ölçüm olarak değil, kendi okumamız olarak söylüyoruz: bağımsız hiçbir Türkçe konuşan etiketleyici bunları yeniden hakemlemedi, dolayısıyla ortak 204 başarısızlığın kaçının etiket hatası olduğu konusunda bir sayı vermeyeceğiz. Söyleyeceğimiz şey şu: güvene göre sıralanmış hata listesinin tepesine, modelin etiketten daha haklı göründüğü vakalar hâkim — ki bu, Frénay ve Verleysen’in (2014) tarif ettiği teşhis ve veri etiketleme bölümündeki etiket denetimi kısmının (Bölüm 5.6) size aramanızı söylediği şey.

Son iki satır başka bir açıdan öğretici. “Almazsanız pişman olursunuz” gerçek bir model hatası: bir şikâyetin bütün sözcüksel işaretlerini taşıyor — pişmanlık, olumsuzlama, bir uyarı — ama tersini söyleyecek şekilde dizilmiş. “İdare eder bir ürün” ise ne bir model hatası ne de açık bir etiket hatası; bir omuz silkme; beş yıldızın yanındaki bir omuz silkme ise bir dil sorunu değil, bir etiketleme uzlaşımı.

İpucuBunun ürettiği kural

Hatalarınızı model güvenine göre azalan sırada dizin ve ilk elliyi elle okuyun. Bunların çoğu etiket hatasına benziyorsa modeli ayarlamayı bırakın — artık etiketleme sürecinizi ölçüyorsunuz ve hiçbir mimari değişiklik bu sayıyı oynatmaz. Bunun yerine yeniden etiketleyin ya da etiketleme fonksiyonunu değiştirin.

12.10.4 Encoder’ın kazandırdıkları, cümle cümle

BERTurk’ün yakalayıp tf-idf’in ıskaladığı 122 şikâyet belli bir örüntü taşıyor ve bu örüntü kelime dağarcığıyla ilgili değil. Aşağıdakiler bunlardan örnekler: tf-idf’in 0,166 eşiğinin hemen altında (0,13–0,15), BERTurk’ün ise 0,9’un üstünde puanladığı belgeler.

p_lin   p_bert   review (glossed)
0.135    0.9987  "After one month's use it snapped in the middle."
0.143    0.9976  "The reception isn't anything to write home about,
                  normal for the price."
0.152    0.9801  "The numbers on the parts are printed wrong; assembling
                  it into a whole is exhausting."
0.143    0.9976  "I put it downstairs in my duplex and it doesn't reach
                  upstairs; upstairs and it doesn't reach downstairs.
                  Very weak … I read the reviews and can't believe it's
                  the same modem."

Bunların hiçbirinde, bir kelime torbası modelinin güçlü ağırlık verdiği klasik şikâyet kelimeleri yok. Birincisi bütün anlamını tek bir nadir fiilde taşıyor: koptu. İkincisi bir ödünleme cümlesi: şikâyet ilk yan cümlede, ikinci yan cümle onu kısmen geri alıyor — tf-idf’in temsil edemeyeceği bir yapı, çünkü sırayı çöpe atmış. Dördüncüsü anlatı biçiminde ifade edilmiş bir şikâyet: tek değerlendirici ifade (“çok zayıf”), ürünün iki kez işini göremediği anlatıldıktan sonra geliyor. Seyrek öznitelikler kelimeye ihtiyaç duyar; encoder cümleye.

İki modelin de paylaştığı hatalar ise, aynı şekilde çevrilmiş hâlleriyle, dört türe düşüyor; en kalabalığı “idare eder” ailesi:

"It drops out now and then, but it'll do."          lukewarm
"It'll do, for the money it's fine."                lukewarm
"A so-so product."                                  lukewarm
"You'll regret it if you don't buy it."             negated regret
"The hose looks low quality."                       hedged
"Downside:"                                         empty

İlgi çekici olan “idare eder” ailesi, çünkü aslında bir modelleme başarısızlığı değil. İdare eder, Türk yorumcuların rutin olarak dört ya da beş yıldızla eşleştirdiği bir omuz silkme; dolayısıyla etiket memnun diyor, metin ise ne memnun ne şikâyet diyor. Hiçbir sınıflandırıcı, etiketlerin kodlamadığı bir ayrımı geri kazanamaz. Son satır daha kötü: bütün metni eksisi kelimesi ve ardından gelen iki nokta üst üsteden ibaret bir yorum. Bir referans etiketi var. Hiç bilgi içermiyor. Her test kümesinin bir kısmı etiketlenemezdir ve metriklerden göremeyeceğiniz bir tavan koyar.

12.10.5 Dört alışkanlık

Yukarıdaki her şey, sırayla yapılmış dört ucuz şey ve yayına alacağınız her sınıflandırıcıya genelleniyor:

1. Yeni modeli, yerini aldığı modelle çapraz tablolayın. Toplam bir iyileşme net bir rakamdır. Neyi bozduğunuzu öğrenin.
2. Maliyetsiz bir özelliğe göre dilimleyin. Uzunluk, kaynak, tarih, ürün kategorisi, belge dili. Kazancı ilan etmeden önce her dilimin içinde de geçerli kaldığını kontrol edin.
3. Hataları güvene göre sıralayın ve listenin tepesini okuyun. Kendinden emin hatalar arasında etiket hataları yoğunlaşır; rastgele örneklemlerde ise gerçek belirsizlik.
4. Kendi hatalarınızı veri kümesininkilerden ayırın. Her hata için şunu sorun: dikkatli bir insan yalnızca metne bakarak bunu doğru bilebilir miydi? Cevap hayırsa bu bir model sorunu değildir ve ayar yapmak onu düzeltmez.

12.11 Sezgi kontrolleri

Her birini açmadan önce cevaplayın. Altısı da bu bölümün bir tartışmayla değil bir ölçümle kapattığı sorular, dolayısıyla cevaplar kontrol edebileceğiniz sayılar taşıyor.

Not1. Bir meslektaşınız bu derlemde %94,3 doğruluk raporluyor. Ne kadar etkilenmelisiniz?

Hiç, ve bunu başka hiçbir şeye bakmadan söyleyebilirsiniz. Her girdiye “memnun” cevabını veren bir model burada %93,68 alıyor, çünkü taban oran bu. %94,3, hiç özniteliği, hiç eğitimi ve hiç parametresi olmayan bir modelin 0,6 puan üstünde.

Düzeltilmemiş baseline (Bölüm 12.4) \(t = 0{,}5\)’te %94,28 alıyor — ve 632 şikâyetin 69’unu yakalıyor. Hiç yoktan biraz daha iyi bir model değil; saygın bir sayının ardına gizlenmiş, neredeyse hiçbir şey yapmayan bir model.

Edinilecek alışkanlık: herhangi bir doğruluk rakamına bakmadan önce çoğunluk sınıfı oranını hesaplayın ve çıkarın. Fark küçükse başka bir metrik isteyin. Matthews korelasyonu en ucuz güvenilir ikame — sabit tahmincilere tam 0,000, rastgele tahmin yürütenlere de sıfıra 0,02’den yakın değerler veriyor.

Not2. Macro-F1’iniz 58,24’ten 77,66’ya çıkıyor ve tek değişen bir sabit. Hile mi yaptınız?

Hayır — sıralamanın oynamadığını gösterebiliyorsanız ve sabit ayrılmış veri üzerinde seçildiyse.

Kanıt sınıf dengesizliği kısmında (Bölüm 12.5): hem önce hem sonra average precision 60,30, AUC 93,24. Bu iki istatistik yalnızca modelin belgeleri dizdiği sıraya bağlı. Dört anlamlı basamağa kadar özdeş çıkmalarının nedeni modelin bayt bayt aynı olması; kıpırdamamış bir sıralama istatistiği de bunu başkasına gösterebileceğiniz kanıttır. Değişen tek şey nereden kestiğimiz.

Hile, 0,166’yı test kümesi üzerinde eşik tarayarak seçmek olurdu. Bu bölümdeki her eşiğin 8.000 belgelik cal dilimi üzerinde seçilip ancak ondan sonra teste uygulanmasının sebebi bu. Bölüm test üzerinde taranmış eşikler de raporluyor — oracle adıyla — ama yalnızca pişmanlığı ölçmeye yarayan bir üst sınır olarak, asla bir sonuç olarak değil.

Not3. 800 etiketiniz ve iki gününüz var. BERTurk’ü fine-tune mu edersiniz, tf-idf mi eğitirsiniz?

800 etikette iki seçenek gerçekten başa baş ve cevap şu: önce, bugün, tf-idf’i eğitin, sonra karar verin.

Ölçülen eğrilerde 800’ün iki yanında da birer nokta var. 500 etikette tf-idf 60,82, BERTurk 56,46 alıyor — seyrek model kazanıyor. 1.000 etikette tf-idf 61,60, BERTurk 71,57 alıyor — encoder on puanla kazanıyor. Sizin 800’ünüz, encoder tarafında dik, seyrek tarafta düz bir kesişim bölgesinin içine düşüyor.

Terazinin dilini kaydıran şey doğruluk değil, maliyet asimetrisi. tf-idf’i eğitmek yaklaşık saniyenin onda birini alıyor. Sonuç ihtiyacınızı karşılıyorsa öğle yemeğinden önce işiniz bitmiş demektir. Karşılamıyorsa hiçbir şey kaybetmediniz; artık elinizde aşılması gereken bir baseline ve çoktan yüklenmiş etiketli bir küme var. Ucuz olanı önce koşturun; genelde kazandığı için değil, öğrenmenin hiçbir maliyeti olmadığı için.

Şimdi sorunun size sunmadığı seçeneğe dikkat edin. Bölüm 12.9 bu bütçenin yakınında üçüncü bir cevap ölçtü; bu cevabı doğru aktarmak için kendi değerlendirme kümesiyle birlikte vermek gerekiyor: paylaşılan 2.000 belgelik altörneklemde promptlu 36B’lik bir model sıfır etiketle 81,56 macro-F1 alıyor; BERTurk aynı belgeler üzerinde 1.000 etiketle 72,78 alıyor — eşleştirilmiş bootstrap bu farkı prompt’un lehine 8,79 puan olarak kestiriyor. Yine de tf-idf’i eğitin; saniyenin onda birini alır ve baseline’ınız odur. Ama “bu ikisinden hangisini eğiteyim” artık sorunun tamamı değil. Kararı belirlemesi gereken şey, özgün cevapta hiç olmayan sütun: prompt, seyrek modelin 0,014 saniyesine karşı 1.000 belge başına 352 saniyeye mal oluyor ve size kaydıracak bir eşik vermiyor.

Not4. 500 etiket eklemek AUC’yi düşürdü. Geri mi almalısınız?

Önce başka nelerin oynadığına bakın. 500’den 1.000 etikete geçerken BERTurk’ün AUC’si 83,00 → 82,76 düşüyor; aynı adımda average precision 26,98 → 45,72 ve macro-F1 56,46 → 71,57 yükseliyor.

Bu bir çelişki değil, iki metriğin farklı bölgeleri ölçmesi. Yanlış pozitif oranının paydası 9.368 memnun yorum; dolayısıyla kolay çoğunluk içindeki hatalar bu orana zar zor yansıyor. Precision’ın paydası ise fiilen işaretlediğiniz belge sayısı, bu da çok daha küçük bir sayı (Davis ve Goadrich 2006). Fazladan etiketler modeli tam olarak kararın verildiği yerde iyileştirdi ve sıralamanın hiçbir çalışma noktasının düşmediği bir kısmını hafifçe bozdu.

Yalnızca ürününüz sıralamanın tamamında düşük eşiklerle çalışıyorsa geri alın. Bizimki öyle çalışmıyor — kimse 10.000 yorumun hepsini okumuyor — o hâlde yayına alın. Genel kural: dengesiz bir problemde average precision’ı taban oranla kıyaslayarak raporlayın (burada %6,32’ye karşı 60,30, yani taban orana göre 9,54 kat iyileşme (lift)) ve AUC’yi ikincil sayın.

Not5. Sınıf ağırlıklandırma F1’inizi yükseltti. Bunun bedeli ne oldu?

Modelin kalibrasyonu; hem de muhtemelen ödemek istediğinizden fazlası.

class_weight="balanced" macro-F1’i 58,24’ten 76,09’a çıkarıyor ve beklenen kalibrasyon hatasını 3,96’dan 14,18’e taşıyor — 3,6× bir artış. Yeniden ağırlıklandırılmış modelin ortalama öngörülen olasılığı, gerçek oran 0,9368 iken 0,795. Model, çalışacağı dünyanın önseli olmayan bir önsel öğrenmiş.

Çıktıyla yaptığınız tek şey argmax ise bunun hiçbir bedeli yok. Sayı bir insana gösterildiği (“%87 ihtimalle şikâyet”), bir maliyetle çarpıldığı, akış aşağısındaki bir kurala verildiği ya da model sürümleri arasında karşılaştırıldığı anda ise bedel ortaya çıkıyor. Üstelik bu bedeli hiç ödemek zorunda değildiniz: ağırlıklandırılmamış modelde eşiği kaydırmak 77,66’ya ulaşıyor — sınıf ağırlıklandırmasından daha iyi — ve ECE 3,96’da hiç kıpırdamıyor.

Van den Goorbergh ve arkadaşları klinik risk modellerinde aynı ödünleşimi buldu ve bunun nadiren yapmaya değer olduğunu savundu (van den Goorbergh vd. 2022).

Not6. Ders kitabındaki maliyet-optimal eşiği uyguladınız ve inceleme kuyruğu patladı. Ne yanlış gitti?

Formül neredeyse kesinlikle sorunsuz. Ona verdiğiniz girdi bir olasılık değildi.

Elkan’ın \(q^* = C_{FP}/(C_{FN}+C_{FP})\)’si doğru ve \(q\)’nün kalibre bir olasılık olduğunu varsayıyor (Elkan 2001). 100’lük bir maliyet oranında bu eşik 0,0099. Formüle ham lojistik regresyon puanlarını verirseniz model 9.368 memnun yorumun 8.073’ünü işaretler, çünkü puanları 0,0099’un neredeyse her şeyi yakaladığı bir banda sıkışmıştır. Aynı modelden gelen, izotonik yöntemle kalibre edilmiş puanları verirseniz 3.345 yorum işaretler.

Ölçtüğümüz yedi maliyet oranı boyunca formül ham puanlarda %8 ile %56 arası fazla harcıyor; kalibre puanlarda %1 ile %7 arası. Teşhis aracı bir kod incelemesi değil, bir güvenilirlik grafiği — hata aritmetikte değil, sayılarda.

12.12 Mülakat soruları

Atıf üzerine — Bölüm 2’dekiyle aynı uyarı. Bunlar, ikisi de ücretsiz olan iki güvenilir kamuya açık kaynakta tekrar tekrar geçen sorular: Chip Huyen’in Introduction to Machine Learning Interviews kitabı (Huyen 2021) ve AIMLInterviews. Kaynak göstermeden “X şirketinin sorduğu sorular” diye liste veren sayfalara temkinle yaklaşın; bir soruyu bir şirkete atfetmek için doğrulanabilir bir kaynak arayın.

1. Sınıf dengesizliğiyle nasıl başa çıkarsınız? Beklenen cevap aşırı örnekleme, eksik örnekleme, SMOTE ve sınıf ağırlıklarını sıralar. Daha iyi cevap neyin bozulduğunu sorarak başlar, çünkü cevap genellikle model değil eşiktir. Ölçümü verin: %6,32’lik bir azınlık sınıfında tek bir eşiği kaydırmak, yeniden eğitim ve fazladan satır olmadan 77,66 macro-F1’e ulaştı. Sınıf ağırlıkları 76,09’da, aşırı örnekleme 77,63’te, SMOTE 74,72’de ve eksik örnekleme 62,98’de kaldı. Sonra çekinceyi verin, çünkü tasarımı anladığınızı gösteren kısım bu: kollardan yalnızca eşik kolu ayarlandı ve average precision, ayarlanmış bir aşırı örnekleme kolunun muhtemelen kıl payı öne geçeceğini gösteriyor. Bulgu, eşiğin en iyi olduğu değil, maliyetsiz olduğu. Sonra SMOTE’un dokuz düşük boyutlu yoğun sayısal veri kümesinde değerlendirildiğini ve yazarlarının metin verisini gelecek çalışma olarak listelediğini ekleyin (Chawla vd. 2002) — makaleyi, hakkındaki blog yazısını değil, okuduğunuzu gösteren cümle bu.

2. Precision, recall, F1, ROC-AUC, PR-AUC — hangisini ne zaman kullanırsınız? Her birinin neye böldüğünü söyleyin. Yanlış pozitif oranı çoğunluk sayısına bölüyor; precision işaretlediğiniz şeye bölüyor. Dengesiz bir problemde bu paydalar bir iki büyüklük mertebesine varan ölçüde farklı olabilir, dolayısıyla iki eğri modelleri farklı sıralar (Davis ve Goadrich 2006) — bizimkiler iki BERTurk checkpoint’i arasında yön olarak bile anlaşmadı. Pratik kuralla bitirin: PR-AUC’yi taban oranla birlikte verin ki okur taban orana göre kaç kat iyileşme (lift) olduğunu görebilsin. Doğruluğu da asla yanında çoğunluk sınıfı oranı olmadan vermeyin.

3. Kalibrasyon nedir ve nasıl test edersiniz? Bir model, 0,8 puanladığı vakaların yaklaşık %80’i gerçekten pozitifse kalibredir. Bir güvenilirlik diyagramı ve bir beklenen kalibrasyon hatasıyla test edin, sonra da — çoğu adayın kaçırdığı kısım bu — hangi ECE olduğunu söyleyin. Guo ve arkadaşlarının ECE’si en üst etiket güvenini (\(\max_k p_k\)) kutucuklara ayırır ve argmax’ın ne sıklıkla doğru olduğunu sorar (Guo vd. 2017); \(P(\text{sınıf }1)\) üzerinden kutulamak farklı bir istatistiktir. Sınıf ağırlıklı modelimizde bu iki ECE 8,98 ve 14,18 çıktı. İkisi de doğru; tanımı olmayan bir sayı ise değil.

4. Platt ölçeklemesi mi izotonik regresyon mu? İzotonik yöntem parametrik değil ve herhangi bir monoton bozulmayı kestirebilir; Platt iki parametreli bir sigmoid ve kestiremez (Platt 1999; Zadrozny ve Elkan 2002). Karar, elinizde ne kadar ayrılmış veri olduğuyla ilgili: Niculescu-Mizil ve Caruana, kabaca birkaç yüz ile bin kalibrasyon noktasının altında Platt’ı önde, üstünde ise izotonik yöntemi eşit ya da daha iyi buldu (Niculescu-Mizil ve Caruana 2005). Kalibrasyon kümenizin boyutunu söyleyin. Bizimki 8.000; izotonik 0,69, Platt 0,94 çıktı — kendi kestiricimizin gürültüsünün içinde kalan bir fark. Dolayısıyla söyleyebileceğimiz şey, bu kalibrasyon kümesi boyutunda ikisinin de yeterli olduğu; onların sonucunun öngördüğü de bu. “İzotonik kazandı” demek, gürültü tabanı yarım puan olan bir istatistikten çeyrek puan okumak olurdu.

5. Üretimdeki bir sınıflandırıcı için karar eşiğini nasıl seçersiniz? Varsayılan olarak asla 0,5. Sonuçlardan kim sorumluysa ondan bir maliyet oranı alın ve \(q^*\)’yi bu orandan türetin. Sonra — yöntemin işe yarayıp yaramayacağını belirleyen adım bu — türetmeye güvenmeden önce puanların kalibre olduğunu doğrulayın. Maliyetler sabitse ve tek bir çalışma noktası yeterliyse, eşiği doğrudan ayrılmış veri üzerinde taramak meşru bir kestirme. Ölçümlerimizde bu yolun pişmanlığı, önce kalibre edip sonra eşiği türeten yolunkinin iki yüzde puanı yakınında kaldı. Kalibrasyon asıl, maliyetler değişebiliyorsa ya da sayı bir insana gösteriliyorsa zahmetine değiyor.

6. Sınıflandırma için ne zaman LLM kullanmazsınız? Etiketiniz olduğunda, işlenecek hacim büyük olduğunda ve bir kelimeye değil bir sayıya ihtiyacınız olduğunda. Bir hüküm değil, eğriyi verin: bizim görevimizde promptlu 36B’lik bir mixture-of-experts, fine-tune edilmiş BERTurk’ü 1.000 etikette 8,79 macro-F1 ile yendi, 2.000’de 0,08 puanla berabere kaldı (\(p = 0{,}97\)) ve 40.000’de 4,73 ile kaybetti. Bu sonuçların hepsi aynı 2.000 belge üzerinde eşleştirilmiş bootstrap ile sınandı. Sonra beraberliği fiyatlandırın: bu düzenekte encoder bir belgeyi 142× daha ucuza sınıflandırıyor. Düzenek, batch’li bir encoder’ın karşısında tek akışlı, 4-bit yerel bir sunucu; küçük bir ekibin gerçekte karşılaştığı karşılaştırma da bu. Düzgün batchlenmiş, barındırılan bir API farkı daraltır, ama alttaki token başına aritmetiği değiştirmez. Dolayısıyla kalitede başa baş olmak, gerçekte başa baş olmak demek değil. Çoğu adayın kaçırdığı kısım üçüncü eksen. Zero-shot bir model ŞİKAYET kelimesini döndürür, dolayısıyla ROC eğrisinden, kalibrasyon eşlemesinden, maliyetten türetilmiş eşikten ve taramadan — bu bölümdeki her aletten — vazgeçersiniz. En iyi promptlu koşumuz %56,98 precision ve %80,95 recall’da kaldı ve ayarlanabilecek hiçbir düğme yoktu. Literatürü ve sınırlarını anarak kapatın: Edwards ve Camacho-Collados (2024), 16 veri kümesinde tam veriyle fine-tuning’i 0,119 micro-F1 önde, one-shot rejimde ise promptlamayı önde buldu. Bucher ve Martini (2024) ise kesişimi kabaca 200 gözlemin üstüne koydu; ama bunu modern, talimatla ayarlanmış bir modelle değil, zero-shot BART-large-MNLI ile karşılaştırarak ölçtü. Bizimki onlarınkinden bir büyüklük mertebesi yukarıda ve asıl mesele bu — kesişim, karşılaştırdığınız çiftin bir özelliğidir, bir sabit değil.

7. Modeliniz çevrimdışı %94 doğru ve kullanıcılar her şeyi kaçırdığını söylüyor. Hatayı bulun. Neredeyse her zaman eşik, taban oran ya da bir dağılım kayması; olasılık sırası da bu. Tek bir sayıya değil, karışıklık matrisine bakın: bizimki %94,28 doğrulukta 632 şikâyetin 69’unu yakalıyordu. Sonra çevrimdışı taban oranın üretimle örtüşüp örtüşmediğine bakın. Şikâyet oranı %6,32 olan veride kalibre edilmiş bir model, şikâyet oranı %15 olan bir akışta sistematik olarak gerekenden az işaretler. Sonra çevrimdışı sayıya sızıntı olup olmadığına, özellikle de herhangi bir eşiğin ya da kalibratörün değerlendirme kümesi üzerinde ayarlanıp ayarlanmadığına bakın.

12.12.1 İkiden çok sınıfa ne taşınıyor

Bu bölümdeki her şey ikili ve bu bir gözden kaçırma değil, bir seçim: dengesizlik, eşikler ve maliyetler tek bir kesme noktası varken en net hâlde. Hangi parçaların oynadığını söyleyelim.

Üç şey olduğu gibi taşınıyor: macro-F1, çoğunluk sınıfı baseline’ı ve hatalarınızı güvene göre sıralayıp okumak. İki şey biçim değiştiriyor. Tek etiketli çok sınıflı durumda ayarlanacak sınıf başına bir eşik yok, çünkü sınıflar birbiriyle yarışır. Hata maliyetleri eşitse karar, kalibre olasılıklar üzerinde bir argmax’tır; Elkan’ın formülü de tam bir \(K \times K\) maliyet matrisi üzerinde bir argmin’e dönüşür: \(\hat{y} = \arg\min_i \sum_j p_j C_{ij}\). Sınıf başına eşikler, aşağıdaki çok etiketli duruma aittir; orada sınıflar birbiriyle yarışmaz. Çok sınıflıya taşınan bir eşik yine de var ve kurmaya değer: \(\max_k p_k\) üzerinde ya da ilk iki sınıf arasındaki fark üzerinde bir ret eşiği; altında kalan her şeyi bir etikete değil bir insana gönderir. En çok değişen kalibrasyon: Platt ve izotonik ikili eşlemelerdir, dolayısıyla çok sınıflı durumda ya bire-karşı-hepsi kalibrasyon ya da bir matris/vektör ölçekleme varyantı gerekiyor. Tam da bu durumda Guo vd.’nin (2017) en üst etiket ECE’si bir basitleştirme olmaktan çıkıp doğal istatistik hâline geliyor. Çok etiketli durum ise üçüncü bir vaka: \(K\) bağımsız eşikli \(K\) bağımsız ikili problem ve taban oranları iki büyüklük mertebesi farklı olabilen etiketler üzerinden bir macro-F1. Hiyerarşik etiketler (kategori → alt kategori) de bu durumlardan birine indirgenir: ya yaprak etiketler üzerinde tek bir çok sınıflı problem kurarsınız ya da her düzey için ayrı bir sınıflandırıcı; ikincisinde üst düzeydeki bir hata alt düzeye taşınır, bu yüzden metrikleri düzey düzey raporlayın.

12.13 2026 alet çantası

Bu bölümdeki her şey tek bir dizüstü bilgisayarda, aşağıdaki sürümlerle koştu. Bir kitapta sürüm sabitlemek kaderin cilvesine davetiye çıkarmak, ama sabitlememek daha kötü — buradaki sayılar ancak sürümleri belirtilmiş bir yazılım yığınıyla yeniden üretilebilir.

Bu sayıların çıktığı yığın. Python 3.14.5, Apple Silicon

kütüphane	kullanılan sürüm	burada ne işe yarıyor
scikit-learn	1.9.0	TfidfVectorizer, LogisticRegression, IsotonicRegression, bütün metrikler ve eğriler
transformers	5.15.0	BERTurk’ü yükleme ve fine-tune etme
torch	2.13.0	fine-tuning’in üzerinde koştuğu MPS arka ucu
imbalanced-learn	0.14.2	RandomOverSampler, RandomUnderSampler, SMOTE
scipy	1.18.0	sıcaklığı kestiren, sınırlı aralıkta çalışan tek değişkenli minimizasyon yordamı
numpy / pandas	2.5.2 / 3.0.5	dizi işleri, Parquet gidiş-dönüşü, bölme
ollama	0.24.0	dört yerel LLM’i servis etme (Bölüm 12.8) — llama3.2:3b, qwen3.5:9b, gemma3:27b, qwen3.6:35b-a3b, hepsi Q4_K_M nicemlenmiş

Bilmeye değer, yukarıda kullanılmadı:

Daha geniş ekosistem, yazım anındaki sürümlerle

kütüphane	güncel sürüm	ne zaman kullanılır
setfit	1.1.3	Tunstall vd.’nin (2022) karşıtsal few-shot reçetesi, tek bir nesne hâlinde. Sınıf başına yüzlerce değil onlarca etiketiniz varken doğru ilk deneme
ModernBERT ve çok dilli ardılları	2025–2026	yeni bir projede BERTurk’ten önce denenecek encoder’lar (Warner vd. 2025); ModernBERT’in kendisi İngilizce ve kod üzerinde eğitildi, Türkçe için mmBERT gibi çok dilli bir ardılını kullanın — aynı fine-tuning reçetesi, rotary embedding, 8.192 token’lık bağlam ve belirgin biçimde hızlı eğitim
sentence-transformers	5.7.0	dondurulmuş embedding’ler artı doğrusal bir sınıflandırma katmanı (linear head) — eğitim maliyetinin çok küçük bir kısmıyla, çoğu zaman tam fine-tuning’in bir iki puan yakınında
peft / accelerate	0.20.0 / 1.14.0	encoder buradaki gibi sığmamaya başladığında LoRA ve dağıtık eğitim (Bölüm 9)
netcal	1.4.0	scikit-learn’ün getirdiğinin ötesinde kalibrasyon yöntemleri ve diyagramlar; kutulama ve beta kalibrasyonu dâhil
mapie	1.5.0	conformal prediction (konformal tahmin) — kalibre bir olasılık yerine, kapsama oranı garantili bir etiket kümesi. “Bilmiyorum”un geçerli bir çıktı olması gerektiğinde doğru araç
cleanlab	2.9.0	eğitim verinizdeki etiket hatalarını buluyor. Etiketleri yıldız puanlarından gelen bir derlemde bu, genellikle harcayabileceğiniz en yüksek getirili saat
optuna	4.9.0	tarama artık bir for döngüsüne sığmadığında hiperparametre araması
onnxruntime	1.28.0	fine-tune edilmiş bir encoder’ı CPU servisi için dışa aktarma; çıkarımda tipik olarak PyTorch eager kipinden 2–4× hızlı
skops	0.14.0	scikit-learn modellerini pickle olmadan kalıcılaştırma — ki denetiminizde olmayan hiçbir yerden pickle çözmemelisiniz
shap	0.52.0	biri neden diye sorduğunda tahmin başına katkı payları — daha ucuz alternatif için hata analizi kısmına (Bölüm 12.10) bakın

İki eksik kasıtlı. xgboost (3.4.1) ve lightgbm (4.7.0) tablo verisinde mükemmel ve yüksek boyutlu seyrek metinde nadiren rekabetçi; orada L2 cezalı doğrusal bir model zaten doğru tümevarımsal önyargıya (inductive bias) yakın. fasttext (0.9.3) ise gerçekten hızlı bir gözetimli baseline olmayı sürdürüyor, ama fiilen bakımsız; scikit-learn bu boyuttaki bir derlemde sizi aynı yere götürüyor.

12.14 Lab: gerçek bir servis bütçesiyle bir sınıflandırıcı yayına alın

Teslim edilecek şey şu biçimde tek bir paragraf: “gelen belgelerin %X’ini işaretliyoruz, Z’lerin %Y’sini yakalıyoruz, belge başına W milisaniye maliyetle — ve seçtiğimiz eşik şu, sebebi de bu”. Her cümleciği, yaptığınız bir ölçüme dayanarak savunabilmeniz gerekiyor.

12.14.1 Neye ihtiyacınız var

Elle oluşturmadığınız ikili bir etiketi olan, birkaç bin belgelik bir derlem — yıldız puanları, çözülmüş/çözülmemiş talepler, spam işaretleri, moderasyon sonuçları. Dengesiz olmalı; azınlık sınıfınız %30’un üstündeyse, oranı %30’un altına inene kadar onu altörnekleme ile azaltın, çünkü bu bölümün bütün disiplini ancak sınıflar dengesiz olduğunda önem taşıyor. 1’den 5’e kadarki adımlar için tek başına scikit-learn yeterli.

12.14.2 Adım 1 — hiçbir şey eğitmeden önce çoğunluk sınıfı baseline’ını yazın

Çoğunluk sınıfı oranını ve üç basit politikanın doğruluğunu ve macro-F1’ini raporlayın: hep-çoğunluk, hep-azınlık ve yazı tura. Bunun için dört satır kod yeter ve bu tablo raporunuzdaki en faydalı tablo olur, çünkü sonraki her sayı ona göre okunur. Bizimkiler doğrulukta 93,68 / 6,32 / 50,21 ve macro-F1’de 48,37 / 5,94 / 38,57 idi.

12.14.3 Adım 2 — ikiye değil, üçe ayırın

fit, cal, test — 64 / 16 / 20 makul bir varsayılan ve bu bölümün kullandığı bölme. Devam etmeden önce, hangi niceliklerin cal’a dokunmasına izin verildiğini yazın: eşik, kalibratör, maliyet-optimal çalışma noktası. 7. adıma kadar hiçbir şey test’e dokunamaz.

Bir kalibrasyon dilimi ayıramıyorsanız bunu açıkça söyleyin ve bunun yerine çapraz doğrulamalı kalibrasyon kullanın — ama kalibratörü sessizce eğitim verisi üzerinde ayarlamayın. Burada bunu yapmanın ölçülmüş cezası 0,69’a karşı 2,39 ECE idi ve tehlikeli olmasının sebebi, 2,39’un yanlış görünmemesi.

12.14.4 Adım 3 — seyrek baseline’ı ve etiket bütçesi eğrisini kurun

1–2 gram üzerinde tf-idf, oradan lojistik regresyona. Sonra 200, 500, 1.000, 2.000 ve bütün etiketlerinizde yeniden eğitin ve macro-F1’i bütçeye karşı çizdirin. İki şey arıyorsunuz: eğrinin düzleşip düzleşmediği (bizimki 40.000’de bile düzleşmemişti) ve kazancın ne kadarının azınlık sınıfında olduğu (bizde: 41,84 azınlık F1’ine karşı 20,75 macro-F1 puanı).

12.14.5 Adım 4 — eşiği cal üzerinde tarayın ve tabloyu raporlayın

\(t\)’yi 0,05’ten 0,95’e kadar tarayın ve her değerde doğruluğu, precision’ı, recall’u, azınlık F1’ini, macro-F1’i ve MCC’yi kaydedin. Tablodan cevaplanacak iki soru: \(t \ge 0{,}2\) aralığında doğruluk ne kadar oynadı ve en yüksek doğruluk veren eşikle en yüksek macro-F1 veren eşik aynı mı? Bu derlemde (sergileme amacıyla test üzerinde okununca) cevaplar 1,3 puan ve hayır idi. (0,2’nin altını da tarayın; doğruluk birden 68,98’e düşüyor — ilginç aralığın, doğruluğun düz göründüğü aralık olmasının sebebi de bu.)

12.14.6 Adım 5 — puanlarınızın olasılık olup olmadığını kontrol edin

Öngörülen puanları kutulayın, gözlenen sıklığı ortalama öngörülen olasılığa karşı çizdirin ve ECE ile MCE’yi hesaplayın. Hangi ECE’yi hesapladığınızı belirtin. Sonra cal üzerinde Platt ve izotonik kalibratörleri ayarlayıp yeniden ölçün. ECE’niz zaten yaklaşık 1’in altındaysa durabilirsiniz; 5’in üstündeyse, puanı olasılık gibi kullanan akış aşağısındaki her şey artık niceleyebileceğiniz bir farkla yanlış.

Adım 4 ile 5’in çekirdeği birkaç satır; clf, fit üzerinde eğitilmiş model:

# Adım 4: eşiği cal üzerinde seçin (p_cal = azınlık sınıfının puanı)
p_cal = clf.predict_proba(X_cal)[:, 1]
ts = np.arange(0.01, 1.0, 0.01)
t_best = max(ts, key=lambda t: f1_score(y_cal, p_cal >= t, average="macro"))

# Adım 5: eğitilmiş modeli dondurup izotonik kalibratörü cal üzerinde ayarlayın
from sklearn.calibration import CalibratedClassifierCV
from sklearn.frozen import FrozenEstimator
iso = CalibratedClassifierCV(FrozenEstimator(clf), method="isotonic").fit(X_cal, y_cal)

12.14.7 Adım 6 — bir maliyeti eşiğe çevirin

Sonuçlardan sorumlu birinden bir \(r = C_{FN}/C_{FP}\) oranı isteyin. “İkisi de kötü” cevabını kabul etmeyin; kaba da olsa bir sayı seçmelerini sağlayın. Yoksa o sayıyı, 0,5’i yazan kişi seçmiş olur. \(q^* = 1/(1+r)\)’yi hesaplayın, kalibre puanlarınıza uygulayın ve toplam maliyeti iki basit politikanın maliyetiyle karşılaştırarak raporlayın. Modeliniz her şeyi işaretle politikasını yenemiyorsa bu, projeniz hakkında yayımlanabilir bir bulgu.

12.14.8 Adım 7 — test’i bir kez açın

Seçilmiş her eşiği ve kalibratörü koşturun, karışıklık matrisini üretin ve paragrafı yazın. Sonra bir şey daha koşturun: süresini ölçün. Saniyede belge, tek işlem, fiilen servis edeceğiniz batch boyutunda. Koşturmayı göze alamayacağınız bir model, model değildir ve bu, insanların yayına alacakları haftaya kadar ölçmeyi unuttuğu sayıdır.

12.14.9 Ne teslim edilecek

Basit referans tablosu, etiket bütçesi eğrisi, eşik taraması, kalibrasyon öncesi ve sonrası güvenilirlik grafiği, maliyet tablosu ve paragraf. Kabaca iki sayfa. Paragraftaki herhangi bir sayı tablolardan birinde geçmiyorsa, o sayıyı silin.

12.15 Alıştırmalar

1. Çoğunluk sınıfı baseline’ını yeniden üretin. Elinizdeki herhangi bir dengesiz derlemde, her zaman çoğunluk sınıfını tahmin eden bir sınıflandırıcının doğruluğunu hesaplayın. Sonra o derlem üzerinde yayımlanmış bir sonuç bulun ve bu baseline’ın ne kadar üstünde durduğunu kontrol edin. İki sayıyı birlikte raporlayın.

2. Bir eşiği bozun. Eğitilmiş ikili bir sınıflandırıcı alın ve eşiğini 0,05’ten 0,95’e tarayın. Doğruluğu ve azınlık sınıfı recall’unu aynı eksenlere çizdirin. Doğruluğu en yükseğe çıkaran eşiği ve macro-F1’i en yükseğe çıkaran eşiği raporlayın ve neden farklı olduklarını tek cümleyle açıklayın.

3. Sıralamanın oynamadığını kanıtlayın. Sınıf dengesizliği kısmındaki deneyi (Bölüm 12.5) kendi verinizde tekrarlayın: “düzeltme yok artı ayarlanmış bir eşik” yaklaşımını class_weight="balanced" ile karşılaştırın. İkisi için de macro-F1 ve average precision raporlayın. Average precision’lar eşit olsaydı bunun ne anlama geleceğini, eşit olmasaydı ne anlama geleceğini açıklayın.

4. Hataları fiyatlandırın. Bir yanlış negatifin bir yanlış pozitiften 10× pahalı olduğu bir görev için maliyet matrisi kurun. \(q^*\)’yi türetin, ham ve kalibre puanlara uygulayın ve her birinin toplam maliyetini her şeyi işaretlemenin maliyetine karşı raporlayın. Kalibrasyonun sizin biriminizde kaç ettiğini belirtin.

5. Kalibratörü bilerek bozun. Bir izotonik kalibratörü ayrılmış puanlar yerine eğitim puanlarınız üzerinde ayarlayın ve ECE’yi iki şekilde de ölçün. Alıştırmanın amacı, sızdırılmış sayının ne kadar sıradan göründüğünü görmek.

6. Kesişimi bulun. Bir encoder’ı 200, 500, 1.000 ve 2.000 etikette fine-tune edin ve aynı eksenlerde seyrek baseline’ınıza karşı çizdirin. Eğrilerin kesiştiği bütçeyi ve her noktanın wall-clock süresi maliyetini raporlayın. Bizim kesişimimizle karşılaştırın ve farkı açıklayın — derlem boyutu, dil, belge uzunluğu ya da sınıf dengesi.

7. Elli hata okuyun. En iyi modelinizin yanlış yaptığı elli belgeyi güvene göre tabakalı olarak örnekleyin ve her birinin başarısızlık kipini elle etiketleyin. En yaygın üç kipi sayılarıyla raporlayın. En büyük kategori “etiket yanlış” ise, herhangi bir mimari değişikliğinden daha değerli bir şey öğrendiniz.

8. Yaygın kanıyı yeniden ölçün. Bir yerel model alın ve 500 belgede zero-shot sınıflandırmayı iki kez koşturun: bir kez talimatı derleminizin dilinde, bir kez İngilizce yazarak. Farkı, iki ayrı aralıkla değil, aynı belgeler üzerinde eşleştirilmiş bir bootstrap ile raporlayın. Sonra en az 3× büyük bir modelle tekrarlayın. “Prompt’ları İngilizce yazın” tavsiyesinin iki modelden herhangi birinde geçerliliğini koruyup korumadığını belirtin.

9. Puanı kontrol etmeden önce ayrıştırma oranını kontrol edin. Bir zero-shot koşusunu, belge başına ham cevabı, bitiş sebebini ve ayrıştırıcınızın başarılı olup olmadığını kaydedecek şekilde donatın. Şimdi çıktıyı 8 token’da sınırlayın ve yeniden koşturun. Doğruluğu ve ayrıştırma oranını raporlayın ve yalnızca doğruluğu loglasaydınız doğruluğun nasıl görüneceğini söyleyin. Akıl yürütme ya da düşünme kipi olan bir model kullanın — bu başarısızlık ancak böyle bir modelde ortaya çıkıyor; dersin kendisi de bu.

10. Beraberliği fiyatlandırın. Promptlanan bir modelle fine-tune edilmiş birinin sizin görevinizdeki puanları arasındaki farkın gürültü düzeyinde kaldığını varsayın. İkisi için de, fiilen servis edeceğiniz batch boyutunda, 1.000 belge başına saniyeyi ölçün. Fine-tuning’in bir defalık eğitim maliyetinin kendini amorti ettiği hacmi ve gerçek trafiğinizde her birinin aylık faturasını hesaplayın. Sonra hangisini yayına alacağınızı ve nedenini söyleyin — cevap yavaş olan olabilir. Amorti hacminizin etiketleri üretme maliyetini sayıp saymadığını belirtin. Saymıyorsa, bunu sayıyla aynı cümlede söyleyin.

12.16 Daha derine inmek için

Önce şunu yapın: sınıflandırıcınızın tahmin ettiği olasılıkları histogram olarak çizin. 0 ve 1’de yığılıyorlarsa bu, tek başına bir hüküm değil, kalibrasyonu gözlenen frekanslarla karşılaştırarak kontrol etmek için bir gerekçedir — gerçekten kolay bir problem, hem kendinden emin hem doğru olasılıklar üretir. Güvenilirlik diyagramını çizin; güven hak edilmemişse ihtiyacınız olan şey daha büyük bir encoder değil, kalibrasyon (Bölüm 12.6).

Makalelerin ötesinde

kaynak	ne olduğu
scikit-learn kalibrasyon rehberi	güvenilirlik diyagramları ve her iki kalibratör, çalıştırılabilir örneklerle
Hugging Face LLM kursu	encoder yolunun baştan sona anlatılmasını istiyorsanız fine-tuning bölümleri
setfit	prompt’suz few-shot sınıflandırma; bir LLM’e başvurmadan önce geçmeniz gereken referans
Chip Huyen’in blogu	bir sınıflandırıcının ne zaman doğru ürün kararı olduğunu uygulamalı ML çerçevesinden anlatıyor
StatQuest — Josh Starmer	bu bölümün altındaki istatistiğin başvuru kanalı — ROC, precision-recall ve kalibrasyon yavaş ve doğru anlatılıyor

Birincil kaynaklar

konu	kaynak
modern sinir ağları kötü kalibre edilmiştir	Guo vd. (2017)
iki klasik çözüm	Platt (1999); Zadrozny ve Elkan (2002)
ve size neye mal oldukları	Niculescu-Mizil ve Caruana (2005)
eşikleri 0,5’ten değil maliyetlerden çıkarmak	Elkan (2001)
yeniden örneklemenin neden bir bedeli olduğu	van den Goorbergh vd. (2022); Chawla vd. (2002)
sınıflar çarpıkken PR eğrileri	Davis ve Goadrich (2006)
genellikle asıl tavan olan etiket gürültüsü	Frénay ve Verleysen (2014)
promptlu ve fine-tune edilmiş, ölçülmüş hâliyle	Bucher ve Martini (2024); Edwards ve Camacho-Collados (2024)
prompt’suz few-shot	Tunstall vd. (2022)
bir modelin beyan ettiği güvenin değeri	Xiong vd. (2024); Lin vd. (2022)
sınıflandırmada prompt sırası etkileri	Zhao vd. (2021)
baştan sona kullanılan Türkçe encoder	Schweter (2020)

12.17 Akılda kalması gerekenler

• Başka bir şey hesaplamadan önce çoğunluk sınıfı baseline’ını hesaplayın. Bu derlemin %93,68’i memnun, dolayısıyla hiç özniteliği, hiç parametresi ve hiç eğitimi olmayan bir model %93,68 doğruluk ve 48,37 macro-F1 alıyor. Bir sınıflandırma makalesindeki her doğruluk rakamı o sayıdan uzaklık olarak okunmalı ve dengesiz veride bu uzaklık genellikle utandıracak kadar küçük.
• Bir eşik, bedelsiz 19 puan demektir. Aynı eğitilmiş model — aynı katsayılar, bayt bayt — işaretleme eşiğini 0,5 yerine 0,166 yaptığımız için 58,24’ten 77,66 macro-F1’e çıkıyor. Değişiklik boyunca average precision 60,30’da, AUC 93,24’te kaldı; modelle ilgili hiçbir şeyin oynamadığının kanıtı da bu.
• Veriye dokunmadan önce eşiği deneyin. Beş dengesizlik yöntemi arasında kesme noktasını kaydırmak 77,66’ya ulaştı; aşırı örnekleme 77,63’te, sınıf ağırlıklandırma 76,09’da, SMOTE 74,72’de kaldı. Eşik bunu sıfır eğitim maliyetiyle yaptı, ama yalnızca eşik kolu ayarlanmıştı. Bu yüzden sonucu bir galibiyet diye değil, aynı çalışma noktasına hiçbir bedel ödemeden ulaşmak diye okuyun. Eksik örnekleme ise modeli fiilen yok etti (62,98; average precision 60,30’dan 52,49’a düştü, çünkü eğitim satırlarının %87,4’ü çöpe atıldı). Dengeleme lehine rutin olarak kaynak gösterilen Elkan (2001) tam tersini savunuyor: veriden olduğu gibi öğrenin, sonra kararı hesaplayın.
• Yeniden örnekleme işe yaradığında bile bir bedeli var. van den Goorbergh vd. (2022) dengesizlik düzeltmelerinin kalibrasyona zarar verirken ayırt etme gücüne pek bir şey katmadığını buldu; biz de bunu metinde yeniden ürettik: sınıf ağırlıklandırma ECE’yi 3,96’dan 14,18’e taşıdı ve bir eşiğin veremeyeceği hiçbir şey kazandırmadı.
• Sınıflandırıcınızın verdiği sayı, siz kontrol edene kadar bir olasılık değildir. Kalibratörü modelin hiç görmediği veri üzerinde ayarlayın. Ayrılmış 8.000 belgede izotonik regresyon ile Platt ölçeklemesi başa baş çıktı (ECE 0,69’a karşı 0,94; fark, yukarıda hesaplanan gürültü tabanının içinde). Niculescu-Mizil ve Caruana’nın (2005) kabaca birkaç yüz ile bin kalibrasyon noktasının üstü için öngördüğü de bu: orada izotonik güvenli. Bu sayının altında Platt ölçeklemesi daha güvenli seçim. İzotonik kalibratörü bunun yerine eğitim puanlarında ayarlamak 2,39 verdi: daha kötü, ama bariz biçimde yanlış değil; hatayı tehlikeli kılan da bu.
• İki tane ECE var ve karşılaştırılabilir değiller. Guo vd. (2017) en üst etiket güveni \(\max_k p_k\) üzerinden kutuluyor; ikili bir problemde bu değer \([0{,}5;\ 1]\) aralığında kalır. \(P(\text{sınıf }1)\) üzerinden kutulamak farklı bir istatistik. Hangisini hesapladığınızı söyleyin.
• Bir maliyet matrisi eşiği sizin için seçer. \(q^* = C_{FP} / (C_{FN} + C_{FP})\). Ayrılmış veri üzerinde doğrudan maliyeti en aza indiren kesme noktası için tarama yapmak, kalibre edip formülü uygulamakla aşağı yukarı aynı işi gördü (%1–7’ye karşı %1–6 pişmanlık), dolayısıyla tek bir sabit maliyet oranı için tek bir çalışma noktasına ihtiyacınız varsa kalibrasyonu atlayabilirsiniz. Maliyetler değişebiliyorsa, sayıyı bir insan okuyorsa ya da akış aşağısında bir şey onu çarpıyorsa kalibre edin.
• Seyrek–encoder kesişimi ani ve erken. BERTurk 200 ve 500 etikette tf-idf’e kaybediyor, 500 ile 1.000 arasında kesişiyor ve 2.000 etikette 79,61 alarak tf-idf’in 40.000 etiketin tamamıyla eğitilmiş hâlini (76,21) geçiyor. Daha iyi bir model için yirmi kat az etiket. Eşit bütçede, 40.000 etikette, fark 8,81 macro-F1 ve 15,45 şikâyet-F1.
• O farkı fiyatlandırın. Encoder o 8,81 puan için eğitimde kabaca 970× daha pahalı (seyrek modelin 1,2 CPU saniyesine karşı 1.162 GPU saniyesi; birimler aynı değil, donanım farkı oranı daha da büyütür) ve saniyede yaklaşık 470 belge servis ediyor; seyrek model ise saniyede on binlerce belge işliyor. Buna değip değmediği bir modelleme değil bütçe sorusu ve iki sayı olmadan cevaplayamazsınız.
• Encoder–LLM kesişimi bir eğridir ve bu görevde ~2.000 etikette duruyor. 1.000 etikette promptlu model 8,79 macro-F1 puanıyla kazanıyor (daha azında farkı daha da büyük); 2.000’de ikisi başa baş (0,08 puan, \(p = 0{,}97\)); 40.000’de encoder 4,73 puanla kazanıyor. Başkalarının sayısını aktarmak yerine kendi model çiftinizde ölçün, çünkü kesişim hangi iki modeli eksene koyduğunuzun bir özelliği.
• İki modeli iki aralığa göz kararı bakarak değil, eşleştirilmiş bir testle karşılaştırın. Aynı belgeler üzerinde puanlanan modeller örneklem gürültüsünün büyük kısmını paylaşır, dolayısıyla çakışan marjinal aralıklar hiçbir şey kanıtlamaz. Yukarıdaki her karşılaştırma, farkın 10.000 eşleştirilmiş bootstrap yeniden örneklemesi.
• LLM’ler hakkındaki yaygın kanı zayıf modeller için doğru, güçlü modellerde ise etkisi olsa olsa küçük. Talimatı İngilizce yazmak 3B’lik bir modelde +16,90 macro-F1, 9B’likte +0,54 (%95 aralık +2,25’e kadar) kazandırdı; sekiz örnek gemma3:27b’de +7,17, qwen3.6:35b-a3b’de +0,51 (+2,48’e kadar) kazandırdı. p-değerlerini değil aralıkları aktarın: güçlü model koşularının gösterdiği şey sıfır bir etki değil, iki buçuk puanlık bir üst sınır. İki kural da bir zamanlar geçerliydi. Yayına alacağınız modelde yeniden ölçün.
• Promptlamak size eşiği kaybettirir. Buradaki her promptlu koşu azınlık sınıfında recall’a yatkındı — en iyisi BERTurk’ün 74,42/76,19’una karşı %80,95 recall’da %56,98 precision’a ulaştı — ve hiçbiri düzeltilebilir değil, çünkü zero-shot bir model bir kelime döndürüyor. ROC yok, izotonik eşleme yok, \(q^*\) yok, tarama yok. Bu, macro-F1 farkından daha büyük bir kayıp.
• Beyan edilen bir güven ortalamada doğru olup yine de hiçbir şeyi ayırt etmeyebilir. qwen3.5:9b’nin beyan ettiği güvenin ortalaması %93,53, gerçek doğruluğu ise %92,95 idi: +0,58’lik bir fark ve kendi seçtiği dokuz kutucuk üzerinde 1,80 ECE. Ama model 2.000 belgenin 1.549’una aynı değeri, 95’i verdi. Hata dedektörü olarak encoder’ın 0,843’üne karşı 0,667 AUROC alıyor ve faydalı görünen ≥95 yönlendirme kesme noktası değerlendirme kümesinden okundu; dolayısıyla ayrılmış veride yeniden seçene kadar onu bir oracle sayın.
• Topluluk fırsatı gerçek ve genelde karşılanabilir değil. En iyi LLM ile BERTurk 2.000 belgenin 94’ünde anlaşamıyor ve her seferinde kazananı seçen bir oracle 5,81 macro-F1 puanı kazandırırdı. Bu puanları toplamak, ölçtüğümüz düzenekte belge başına 142× fazla ödemek demek. Fırsatı bulmak için çapraz tablolayın; ona inanmadan önce fiyatlandırın.
• Model değiştirmek bir ödünleşimdir. BERTurk 332 test belgesini düzeltiyor ve tf-idf’in doğru sınıflandırdığı 149 belgeyi bozuyor — net 183, yani 1,83 doğruluk puanı. Bir modeli her değiştirdiğinizde 2×2’lik anlaşmazlık tablosunu kurun, çünkü toplam fark hangi belgelerden vazgeçtiğinizi gizler.
• Encoder’ın üstünlüğü beklenecek yerde yoğunlaşıyor. tf-idf’in hata oranı belge uzunluğu boyunca düz (%4,86–%5,82, eğilim yok); BERTurk’ünki en kısa yorumlarda %4,50’den 200–399 karakterde %3,10’a düşüyor. Her yerde daha iyi değil — uzun belgelerde daha iyi, çünkü olumsuzlama, ödünleme yapıları ve kapsam ilişkileri orada ortaya çıkıyor.
• Hatalarınızı rastgele değil, güvene göre sıralayın. O listenin tepesi, etiket hatalarının yoğunlaştığı yer. Bizimkinde ürünün iki ayda bozulduğunu söyleyen ve şikâyetin listenin başında görünmesi için beş yıldız verdiğini açıklayan bir yorum var — memnun olarak etiketlenmiş, çünkü etiketler anlaşılan yıldız puanlarından geliyor. Model etiketten daha haklı göründüğünde ayar yapmayı bırakın ve etiket denetimini (Bölüm 5.6) yeniden okuyun; Frénay ve Verleysen (2014) da bu konudaki derleme.
• Test kümenizin bir kısmı etiketlenemez. 204 belge iki modeli birden yeniyor ve bunların 137’si şikâyet — test kümesindeki bütün şikâyetlerin %21,7’si. Bunlardan biri, bütün metni “eksisi” kelimesi ve ardından gelen iki nokta üst üsteden ibaret bir yorum. Hiçbir mimari onlara ulaşamıyor ve varlıkları, gerçekten kovalayabileceğiniz puana bir tavan koyuyor.
• Modelinizden önce değerlendirme düzeneğinizden şüphelenin — özellikle sayı iyiyken. Zamanlama taramamızda bir çıkarım koşusu diğer yedisinden 27× yavaş geldi ve bir eğitim epoch’u diğer ikisinden 14× yavaştı. İkisi de modelin bir özelliği değildi. Ama pahalı başarısızlık ters yönde ortaya çıktı: bir LLM %93,75 doğruluk ve 48,39 macro-F1 aldı; bu tam olarak çoğunluk sınıfı baseline’ı. Sebebi şuydu: akıl yürüten bir model 24 token’lık bütçesini, ayrıştırıcının hiç okumadığı bir thinking alanında harcadı ve ayrıştırılamayan her cevap çoğunluk etiketine düştü. Kötü sayı incelenir; iyi sayı yayımlanır. Düzeneğinizi bu asimetriyi hesaba katarak tasarlayın — bir ayrıştırma hatasında asla etiket uydurmayın, düşük ayrıştırma oranında iptal edin, gecelik kuyruktan önce duman testi yapın — çünkü sonuç umduğunuz şey olduğunda kendi şüpheciliğiniz devreye girmeyecek.

Bu bölüm her belgeye tek bir etiket verdi. Bölüm 13 aynı üçlü karşılaştırmayı — klasik model, fine-tune edilmiş encoder, promptlu LLM — etiketin belge yerine her token’a verildiği görevlere taşıyor.

Bucher, Martin Juan José, ve Marco Martini. 2024. Fine-Tuned “Small” LLMs (Still) Significantly Outperform Zero-Shot Generative AI Models in Text Classification. https://arxiv.org/abs/2406.08660.

Chawla, Nitesh V., Kevin W. Bowyer, Lawrence O. Hall, ve W. Philip Kegelmeyer. 2002. “SMOTE: Synthetic Minority Over-sampling Technique”. Journal of Artificial Intelligence Research 16: 321-57. https://doi.org/10.1613/jair.953.

Davis, Jesse, ve Mark Goadrich. 2006. “The Relationship Between Precision-Recall and ROC Curves”. Proceedings of the 23rd International Conference on Machine Learning (ICML ’06) (Pittsburgh, Pennsylvania, USA), 233-40. https://doi.org/10.1145/1143844.1143874.

Edwards, Aleksandra, ve Jose Camacho-Collados. 2024. “Language Models for Text Classification: Is In-Context Learning Enough?” Proceedings of the 2024 Joint International Conference on Computational Linguistics, Language Resources and Evaluation (LREC-COLING 2024) (Torino, Italia), 10058-72. https://aclanthology.org/2024.lrec-main.879/.

Elkan, Charles. 2001. “The Foundations of Cost-Sensitive Learning”. Proceedings of the Seventeenth International Joint Conference on Artificial Intelligence (IJCAI’01) (Seattle, Washington, USA) 2: 973-78.

Frénay, Benoît, ve Michel Verleysen. 2014. “Classification in the Presence of Label Noise: A Survey”. IEEE Transactions on Neural Networks and Learning Systems 25 (5): 845-69.

Gilardi, Fabrizio, Meysam Alizadeh, ve Maël Kubli. 2023. “ChatGPT Outperforms Crowd Workers for Text-Annotation Tasks”. Proceedings of the National Academy of Sciences 120 (30): e2305016120. https://doi.org/10.1073/pnas.2305016120.

Guo, Chuan, Geoff Pleiss, Yu Sun, ve Kilian Q. Weinberger. 2017. “On Calibration of Modern Neural Networks”. Proceedings of the 34th International Conference on Machine Learning, Proceedings of Machine Learning Research, c. 70: 1321-30. https://proceedings.mlr.press/v70/guo17a.html.

Hsieh, Cheng-Yu, Chun-Liang Li, Chih-Kuan Yeh, vd. 2023. “Distilling Step-by-Step! Outperforming Larger Language Models with Less Training Data and Smaller Model Sizes”. Findings of the Association for Computational Linguistics: ACL 2023, 8003-17.

Huyen, Chip. 2021. Introduction to Machine Learning Interviews Book. https://huyenchip.com/ml-interviews-book/.

Kumar, Ananya, Percy Liang, ve Tengyu Ma. 2019. “Verified Uncertainty Calibration”. Advances in Neural Information Processing Systems.

Lin, Stephanie, Jacob Hilton, ve Owain Evans. 2022. “Teaching Models to Express Their Uncertainty in Words”. Transactions on Machine Learning Research. https://openreview.net/forum?id=8s8K2UZGTZ.

Niculescu-Mizil, Alexandru, ve Rich Caruana. 2005. “Predicting Good Probabilities with Supervised Learning”. Proceedings of the 22nd International Conference on Machine Learning (ICML ’05) (New York, NY, USA), 625-32. https://doi.org/10.1145/1102351.1102430.

Nixon, Jeremy, Michael W. Dusenberry, Linchuan Zhang, Ghassen Jerfel, ve Dustin Tran. 2019. “Measuring Calibration in Deep Learning”. CVPR Workshops.

Platt, John C. 1999. “Probabilistic Outputs for Support Vector Machines and Comparisons to Regularized Likelihood Methods”. Içinde Advances in Large Margin Classifiers, editör Alexander J. Smola, Peter L. Bartlett, Bernhard Schölkopf, ve Dale Schuurmans. MIT Press.

Roelofs, Rebecca, Nicholas Cain, Jonathon Shlens, ve Michael C. Mozer. 2022. “Mitigating Bias in Calibration Error Estimation”. Proceedings of the 25th International Conference on Artificial Intelligence and Statistics.

Schweter, Stefan. 2020. BERTurk — BERT Models for Turkish. Versiyon 1.0.0. Zenodo, released Nisan. https://doi.org/10.5281/zenodo.3770924.

Tunstall, Lewis, Nils Reimers, Unso Eun Seo Jo, vd. 2022. Efficient Few-Shot Learning Without Prompts. https://arxiv.org/abs/2209.11055.

van den Goorbergh, Ruben, Maarten van Smeden, Dirk Timmerman, ve Ben Van Calster. 2022. “The Harm of Class Imbalance Corrections for Risk Prediction Models: Illustration and Simulation Using Logistic Regression”. Journal of the American Medical Informatics Association 29 (9): 1525-34. https://doi.org/10.1093/jamia/ocac093.

Warner, Benjamin, Antoine Chaffin, Benjamin Clavié, vd. 2025. “Smarter, Better, Faster, Longer: A Modern Bidirectional Encoder for Fast, Memory Efficient, and Long Context Finetuning and Inference”. Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics. https://arxiv.org/abs/2412.13663.

Xiong, Miao, Zhiyuan Hu, Xinyang Lu, vd. 2024. “Can LLMs Express Their Uncertainty? An Empirical Evaluation of Confidence Elicitation in LLMs”. The Twelfth International Conference on Learning Representations (ICLR 2024). https://openreview.net/forum?id=gjeQKFxFpZ.

Zadrozny, Bianca, ve Charles Elkan. 2002. “Transforming Classifier Scores into Accurate Multiclass Probability Estimates”. Proceedings of the Eighth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining (KDD ’02) (New York, NY, USA), 694-99. https://doi.org/10.1145/775047.775151.

Zhao, Tony Z., Eric Wallace, Shi Feng, Dan Klein, ve Sameer Singh. 2021. “Calibrate Before Use: Improving Few-Shot Performance of Language Models”. Proceedings of the 38th International Conference on Machine Learning (ICML 2021), Proceedings of Machine Learning Research, c. 139: 12697-706. https://proceedings.mlr.press/v139/zhao21c.html.