---
title: 'Çapraz Doğrulama'
source: 'https://academia.sh/tr/kurslar/denetimli-ogrenme/capraz-dogrulama'
course: 'Denetimli Öğrenme'
language: tr
updated: '2026-08-17T18:10:19+00:00'
license: 'CC BY-SA 4.0'
---

# Çapraz Doğrulama

Kat sayısının kendisinin ölçülmesi: k 2'den 10'a süpürüldüğünde kestirimin ortalaması 0,8115 ile 0,8204 arasında kalır, sınama kümesindeki gerçek sayı 0,8056'dır ve gerçeğe en yakın kestirimi k=4 verir. Tek çıkarmalı doğrulama 0,8175 veriyor, gerçekten 0,0119 uzakta, ama bunun için 1.008 eğitim ve 1.015.056 satır işliyor — k=10'un 111,89 katı. Kat başına saçılması 0,3863'tür ve bu sayı belirsizlik değil, tek satırlık katın doğru/yanlış saçılmasıdır; 1.008 kattan hiçbiri iki sınıf birden içermediği için kesinlik ve duyarlılık kat başına hesaplanamaz. Buna karşılık tek çıkarmalı doğrulamanın karıştırmaya bağlılığı tam sıfırdır.

Önceki dersin bütün sayıları tek bir bölmeden okundu. İki doğrusal model arasındaki fark ortalama
mutlak hatada 0,0326, ortalama kare hatada 0,0823 çıktı ve bu sayıların yanında hiçbir dalgalanma
ölçüsü yoktu. Başka bir bölme aynı sıralamayı verir miydi sorusunun yanıtı verilmedi, çünkü elde
tek bir sayı vardı.

Çapraz doğrulama bu boşluğu kapatır: elde kalan veri katlara bölünür, her kat sırayla ölçüm kümesi
olur ve tek sayı yerine birkaç sayı ile bunların saçılması elde edilir. Yordamın kendisi ve kat
içinde hazırlama disiplini M27/K02'de kuruldu; burada varsayılır ve tekrarlanmaz. Bu dersin ölçtüğü
şey **k'nın kendisidir**: kat sayısı büyüdükçe kestirim ne kadar oynuyor, karşılığında kaç eğitim
yapılıyor ve uçtaki seçim — her katta tek satır bırakmak — niçin her zaman daha iyi değil.

- **MD43.** Havuz K01'in eğitim ve doğrulama kümeleridir: 1.008 satır. Sınama kümesinin 252 satırı
  hiçbir kata girmez ve yalnız bir kez, gerçek sayıyı okumak için kullanılır.
- **MD44.** Model, 0/1 etikete en küçük karelerle uydurulan bir doğrusal sınıflandırıcıdır; çıktı
  0,5 eşiğinden kesilir. Küçük ölçekli olmasının nedeni 1.008 kez eğitilecek olmasıdır ve **model
  budur**, bir kitaplığın taklidi değildir.
- **MD45.** Modelin öğrenilen hiçbir hazırlama adımı yoktur; kat içinde öğrenilen tek şey modelin
  kendisidir. Hazırlama disiplininin ölçüsü M27/K02'ye aittir.
- **MD46.** Katlar, karıştırılmış havuzda sıra numarasının k'ya bölümünden kalanına göre atanır;
  böylece her satır tam olarak bir kez ölçüm satırı olur ve kat boyutları en fazla bir satır ayrılır.
- **MD47.** Maliyet birimi **eğitim sayısı** ve **işlenen satır sayısıdır** (katların eğitim
  kümelerinin toplam büyüklüğü). Bu birimler koşumdan koşuma değişmez.
- **MD48.** Kat başına saçılma, katların kendi ortalamalarından ortalama uzaklığıdır ve M26'nın
  değişkenlik ölçüsüdür. Kestirimin belirsizliği değildir.
- **MD49.** Bu derste denenen aday sayısı **birdir**: kat sayısı bir ayar değişkeni değil, ölçme
  yordamının parçasıdır ve modelin kendisini değiştirmez.

## k Süpürülünce Ne Oynuyor

```python
# ORTAK — MODELDIR. M27/K01'in KURGU abone tablosu ayni tohumla yeniden uretilir;
# model, 0/1 etikete en kucuk karelerle uydurulan dogrusal bir siniflandiricidir.
import math

TOHUM, HAM, M32 = 20260218, 1400, 0xFFFFFFFF
BOLGE = [("kuzey", 0.28, 21, 0.00), ("guney", 0.22, 17, -0.10),
         ("dogu", 0.18, 26, 0.30), ("bati", 0.14, 14, -0.05),
         ("merkez", 0.18, 23, 0.05)]


def uretec(t):
    x = ((t ^ (t >> 16)) * 2246822507) & M32
    x = ((x ^ (x >> 13)) * 3266489909) & M32
    s = [(x ^ (x >> 16)) & M32]

    def sonraki():
        s[0] = (s[0] * 1664525 + 1013904223) & M32
        return s[0] / 4294967296
    return sonraki


def ayrik(u, w):
    t = 0.0
    for i, x in enumerate(w):
        t += x
        if u < t:
            return i
    return len(w) - 1


ABONE, VERI = [], []
for i in range(HAM):
    r = uretec(TOHUM + i)
    b = BOLGE[ayrik(r(), [x[1] for x in BOLGE])]
    hane = 1 + ayrik(r(), [0.06, 0.24, 0.30, 0.24, 0.11, 0.05])
    memnun = 1 + ayrik(r(), [0.08, 0.14, 0.27, 0.34, 0.17])
    if r() >= 0.046:
        ABONE.append({"no": 10001 + i, "bolge": b, "hane": hane, "memnuniyet": memnun})
for k in ABONE:
    r, v = uretec(TOHUM + 7000 + k["no"]), []
    for d in range(ayrik(r(), [0.05, 0.12, 0.21, 0.62])):
        v.append(0.0 if r() < 0.038 else math.floor(
            k["bolge"][2] * math.exp((r() + r() + r() - 1.5) * 0.62)
            * (1 - d * 0.05) * 100 + 0.5) / 100)
        r()
    if not v:
        continue
    ort, oyn, r = sum(v) / len(v), max(v) - min(v), uretec(TOHUM + 51000 + k["no"])
    z = (0.052 * (ort - 20) + 0.85 * (min(v) == 0.0) + 0.026 * oyn
         + 0.24 * (k["hane"] >= 5) - 0.20 * (k["memnuniyet"] >= 4) + k["bolge"][3]
         + 0.9 * (k["no"] - 10001) / 1399 + (r() + r() + r() - 1.5) * 1.30)
    x = {"no": k["no"], "hane": k["hane"], "memnuniyet": k["memnuniyet"],
         "donem": len(v), "ort_tuketim": round(ort, 2), "oynaklik": round(oyn, 2),
         "sifir_okuma": int(min(v) == 0.0), "supheli": int(z > 1.35),
         "bolge_ad": k["bolge"][0]}
    for b in BOLGE:
        x["b_" + b[0]] = int(k["bolge"][0] == b[0])
    VERI.append(x)


def karistir(veri, tohum):
    r, s = uretec(tohum), list(range(len(veri)))
    for i in range(len(s) - 1, 0, -1):
        j = int(r() * (i + 1))
        s[i], s[j] = s[j], s[i]
    return [veri[i] for i in s]


K = karistir(VERI, TOHUM + 90000)
SIN = K[1008:]
ALAN = ["ort_tuketim", "oynaklik", "hane", "memnuniyet", "donem", "sifir_okuma",
        "b_dogu", "b_bati", "b_guney"]
D = len(ALAN) + 1


def coz(A, b):
    n = len(A)
    M = [list(A[i]) + [b[i]] for i in range(n)]
    for i in range(n):
        p = max(range(i, n), key=lambda r: abs(M[r][i]))
        M[i], M[p] = M[p], M[i]
        for r in range(n):
            if r != i:
                f = M[r][i] / M[i][i]
                for c in range(i, n + 1):
                    M[r][c] -= f * M[i][c]
    return [M[i][n] / M[i][i] for i in range(n)]


def ogren(s, ceza=1e-4):
    A = [[0.0] * D for _ in range(D)]
    b = [0.0] * D
    for x in s:
        v = [1.0] + [float(x[a]) for a in ALAN]
        y = x["supheli"]
        for i in range(D):
            b[i] += v[i] * y
            for j in range(i, D):
                A[i][j] += v[i] * v[j]
    for i in range(D):
        for j in range(i):
            A[i][j] = A[j][i]
        if i:
            A[i][i] += ceza
    return coz(A, b)


def dogruluk(w, s):
    d = 0
    for x in s:
        p = w[0] + sum(w[i + 1] * x[a] for i, a in enumerate(ALAN))
        d += (1 if p >= 0.5 else 0) == x["supheli"]
    return d / len(s)


HAVUZ = K[:1008]
GERCEK = dogruluk(ogren(HAVUZ), SIN)
c = int(sum(x["supheli"] for x in HAVUZ) * 2 > len(HAVUZ))
TABAN = sum(x["supheli"] == c for x in SIN) / len(SIN)
print(f"havuz {len(HAVUZ)} satir, sinama {len(SIN)} satir")
print(f"gercek sayi {GERCEK:.4f}, taban cizgisi {TABAN:.4f}")
```

```
havuz 1008 satir, sinama 252 satir
gercek sayi 0.8056, taban cizgisi 0.7579
```

Gerçek sayı, havuzun tamamından öğrenilen modelin sınama kümesindeki sayısıdır: 0,8056, tabanın
0,0477 üstünde. Çapraz doğrulamanın işi bu sayıyı **sınama kümesine bakmadan** kestirmektir. Aşağıda
k 2'den 10'a süpürülür ve son satırda uçtaki seçim durur: 1.008 kat, yani her katta tek satır.

```python
def kat_dogrulama(veri, k):
    v = []
    for i in range(k):
        ic = [x for j, x in enumerate(veri) if j % k != i]
        dis = [x for j, x in enumerate(veri) if j % k == i]
        v.append((dogruluk(ogren(ic), dis), len(ic), dis))
    return v


def ortalama(v):
    return sum(v) / len(v)


def sacilma(v):
    o = ortalama(v)
    return (sum((q - o) ** 2 for q in v) / len(v)) ** 0.5


print(f"{'k':>5} {'ortalama':>9} {'sacilma':>8} {'egitim':>7} {'egitim satiri':>14} "
      f"{'islenen satir':>14} {'fark':>8} {'iki sinifli kat':>16}")
for k in list(range(2, 11)) + [1008]:
    v = kat_dogrulama(HAVUZ, k)
    s = [q[0] for q in v]
    ikili = sum(1 for q in v if 0 < sum(x["supheli"] for x in q[2]) < len(q[2]))
    print(f"{k:>5} {ortalama(s):>9.4f} {sacilma(s):>8.4f} {k:>7} {v[0][1]:>14} "
          f"{1008 * (k - 1):>14} {ortalama(s) - GERCEK:>+8.4f} {ikili:>16}")
```

```
    k  ortalama  sacilma  egitim  egitim satiri  islenen satir     fark  iki sinifli kat
    2    0.8135   0.0099       2            504           1008  +0.0079                2
    3    0.8165   0.0014       3            672           2016  +0.0109                3
    4    0.8115   0.0278       4            756           3024  +0.0060                4
    5    0.8185   0.0239       5            806           4032  +0.0129                5
    6    0.8145   0.0237       6            840           5040  +0.0089                6
    7    0.8175   0.0243       7            864           6048  +0.0119                7
    8    0.8204   0.0359       8            882           7056  +0.0149                8
    9    0.8175   0.0286       9            896           8064  +0.0119                9
   10    0.8194   0.0280      10            907           9072  +0.0139               10
 1008    0.8175   0.3863    1008           1007        1015056  +0.0119                0
```

Ortalama sütunu 0,8115 ile 0,8204 arasında dolaşıyor: dokuz farklı k değeri arasındaki toplam
oynama **0,0089**. Fark sütunu hepsinin **artı** olduğunu gösteriyor; çapraz doğrulama sistematik
olarak gerçek sayının üstünde bir sayı veriyor ve bu, M27/K02'de kat içinde hazırlamayla ölçülen
+0,0149'luk sapmayla aynı yöndedir. Nedeni sızıntı değil, havuzun her turda yeniden görülmesidir.

Beklenen düzen, k büyüdükçe eğitim kümesinin büyümesi ve kestirimin gerçek sayıya yaklaşmasıdır.
Eğitim satırı sütunu bu büyümeyi gösteriyor: 504'ten 907'ye, sonra 1.007'ye. Ama fark sütunu bu
düzeni izlemiyor. Gerçeğe en yakın kestirim **k=4**'ten geliyor (+0,0060) ve en uzak kestirim
**k=8**'den (+0,0149). Aradaki sıralama, eğitim kümesinin büyüklüğünden çok kat bölünmesinin
rastlantısından çıkıyor. k'yı 4'ten 10'a çıkarmak kestirimi iyileştirmedi, üç kat daha çok eğitim
yaptırdı.

Saçılma sütunu da tek başına okunamaz. k=3'te 0,0014, k=8'de 0,0359 — on iki kat fark. Üç sayının
saçılması da, on sayının saçılması da kendi başına gürültülüdür; saçılma bir belirsizlik kestirimi
değil, katlar arasındaki dağılımın kaba bir özetidir.

Fark sütununun düzensizliği iki eğilimin üst üste binmesinden gelir ve ikisi ters yöne çeker.
Birincisi **karamsarlıktır**: k küçükken model, kullanıma verilecek modelden daha az satırdan
öğrenir. k=2'de eğitim 504 satırdır, yani sonunda kurulacak modelin gördüğü satırın yarısı; ölçülen
sayı o zayıf modelin sayısıdır. İkincisi **iyimserliktir**: havuzun her satırı k turun k−1'inde
eğitimde, birinde ölçümde yer alır ve aynı 1.008 satır baştan sona yeniden kullanılır. k büyüdükçe
birinci eğilim zayıflar, ikincisi olduğu gibi kalır. Toplamları hiçbir k değerinde sıfırlanmıyor ve
hangi k'nın gerçeğe yakın düştüğü önceden bilinemiyor — tablodaki en yakın satırı işaretlemek ancak
sınama kümesi okunduktan sonra olanaklı, o da çapraz doğrulamanın var oluş nedenini ortadan
kaldırıyor.

## Uçtaki Seçimin Ödediği Bedel

Son satır tek çıkarmalı doğrulamadır: her satır sırayla tek başına ölçüm kümesi olur, model kalan
1.007 satırdan öğrenilir. Kestirim 0,8175, gerçeğin 0,0119 üstünde. Bu sayı k=7 ve k=9'un verdiği
sayıyla **tam olarak aynıdır** ve k=4'ün verdiğinden gerçeğe daha uzaktır.

Maliyeti üç sütunda okunuyor. 1.008 eğitim yapılıyor ve toplam **1.015.056 satır** işleniyor;
k=10'un işlediği 9.072 satırın 111,89 katı. Elde edilen fark, kestirimi 0,0020 oynatmak.

İkinci bedel saçılma sütunundadır: 0,3863. Bu sayı belirsizlik değildir. Tek satırlık bir katta
doğruluk yalnız 0 ya da 1 olabilir, dolayısıyla saçılma zorunlu olarak $\sqrt{p(1-p)}$ değerine
oturur; burada $p = 0{,}8175$ ve $\sqrt{0{,}8175 \times 0{,}1825} = 0{,}3863$. Sayı, modelin
kararlılığı hakkında hiçbir şey söylemez; yalnız ortalamanın kendisini yeniden yazar.

Üçüncü bedel son sütundadır: **iki sınıflı kat sayısı sıfır**. Tek satırlık bir kat tek bir etiket
taşır, dolayısıyla o katta doğru olumlu, yanlış olumlu ve yanlış olumsuz sayımlarının hepsi birden
bulunamaz. Kesinlik, duyarlılık, F1 ölçütü ve eğri altındaki alan **kat başına hesaplanamaz**.
Kat sayısı 2 ile 10 arasındayken her kat iki sınıfı da taşıyor ve bu ölçütlerin hepsi kat başına
hesaplanabiliyor. Doğruluk dışında bir ölçütle çalışılıyorsa tek çıkarmalı doğrulama seçenek
olmaktan çıkar.

## Karıştırmaya Bağlılık

Kat sayısının etkisini ölçerken bir şey sabit tutuldu: havuzun sırası. Kat ataması sıra numarasına
bağlı olduğuna göre, havuz başka türlü karıştırılsaydı kestirim de değişirdi. Aşağıda aynı k
değerleri üç ayrı karıştırmayla yeniden ölçülüyor.

```python
print(f"{'k':>5} " + " ".join(f"{'tohum ' + str(i + 1):>9}" for i in range(3))
      + f" {'sacilma':>9}")
for k in (2, 4, 10, 1008):
    m = []
    for i in range(3):
        h = karistir(HAVUZ, TOHUM + 300 + i * 17)
        m.append(ortalama([q[0] for q in kat_dogrulama(h, k)]))
    print(f"{k:>5} " + " ".join(f"{q:>9.4f}" for q in m) + f" {sacilma(m):>9.4f}")
```

```
    k   tohum 1   tohum 2   tohum 3   sacilma
    2    0.8145    0.8175    0.8125    0.0020
    4    0.8194    0.8194    0.8185    0.0005
   10    0.8194    0.8164    0.8164    0.0014
 1008    0.8175    0.8175    0.8175    0.0000
```

Son satırdaki sıfır tek çıkarmalı doğrulamanın gerçek üstünlüğüdür. Katlar tek satır olduğu için
karıştırma katları değiştirmez; aynı 1.008 kat, aynı sırayla olmasa da aynı kümedir. Kestirim
**tamamen belirlenimlidir** ve tohum seçimi sonucu oynatamaz. k=2 ile aynı ölçüm üç karıştırmada
0,8125 ile 0,8175 arasında geziniyor, saçılma 0,0020.

Bu, tek çıkarmalı doğrulamanın hangi durumda ödediğine değdiğini de söyler: veri azken, tek bir
karıştırmanın kestirimi oynatma payı büyürken ve ölçüt doğruluk gibi kat başına tek satırdan
toplanabilen bir sayıyken. Havuz 1.008 satırken bu koşulların hiçbiri sağlanmıyor ve k=4 ile k=10
arasında bir seçim, on binlerce kat daha ucuza aynı kestirimi veriyor.

Karıştırma saçılmalarının büyüklüğü aynı zamanda bir uyarıdır: k=2'nin karıştırmaya bağlı 0,0020'lik
oynaması, önceki derste iki doğrusal model arasında ölçülen 0,0326'lık farkın on beşte biri kadardır.
Çapraz doğrulamayla iki modeli karşılaştırırken aradaki farkın bu oynamadan büyük olması gerekir.

## Özet

- Kat sayısı 2'den 10'a süpürüldüğünde kestirim 0,8115 ile 0,8204 arasında kalıyor; toplam oynama
  0,0089 ve dokuz değerin hepsi gerçek sayının (0,8056) üstünde.
- Kestirim k ile düzenli iyileşmiyor: gerçeğe en yakın sayıyı k=4 (+0,0060), en uzağı k=8 (+0,0149)
  veriyor; eğitim kümesi büyümesine karşın sıralama kat bölünmesinin rastlantısından çıkıyor.
- Tek çıkarmalı doğrulama 0,8175 veriyor ve 1.008 eğitimle 1.015.056 satır işliyor; k=10'un 111,89
  katı iş karşılığında kestirimi 0,0020 oynatıyor.
- Tek çıkarmalı doğrulamanın kat başına saçılması 0,3863'tür ve bu sayı belirsizlik değil
  $\sqrt{p(1-p)}$ değeridir; ayrıca 1.008 katın hiçbiri iki sınıf birden taşımadığı için kesinlik,
  duyarlılık ve eğri altındaki alan kat başına hesaplanamaz.
- Tek çıkarmalı doğrulamanın gerçek üstünlüğü belirlenimli olmasıdır: üç ayrı karıştırmada saçılması
  tam sıfır, k=2'ninki 0,0020.

## Sonraki Adım

Bu derste denenen aday sayısı birdir. Model tek bir biçimde kuruldu, hiçbir ayar değişkeni
süpürülmedi ve kat sayısı bir ayar değil ölçme yordamının parçası olarak ele alındı. Kursun kuralı
henüz ödenmedi: bir modelin sayısı, o sayıyı bulmak için kaç aday denendiği yazılmadan okunamaz.
Sonraki ders bu hesabı yapar — aynı bütçeyle üç arama yordamı karşılaştırılır ve aday sayısı 1'den
200'e çıkarken doğrulama kümesindeki en iyi sayı ile aynı adayın sınama kümesindeki sayısı arasında
açılan fark basılır. Aile değiştirmenin kattığı fark ile bütçenin şişirdiği fark orada yan yana durur.
