Havuzlama

Önceki dersin evrişimli ağı ilk katmanda 144 konumda bir yanıt üretti ve bunlardan yalnız en büyüğünü kullandı. Kalan 143 sayı atıldı; ağ artık hattın nerede olduğunu bilmiyordu, yalnız olup olmadığını biliyordu. Bu, atmanın en uç biçimidir.

Atma işleminin adı havuzlamadır ve uç biçimiyle sınırlı değildir: pencere boyutu bir ayar değişkenidir ve 1’den ızgaranın tamamına kadar her değeri alabilir. Bu dersin ölçüsü iki yönlüdür — havuzlama neyi geri kurulamaz biçimde atıyor ve karşılığında ne veriyor.

• MI10. Küme, bölme ve taban çizgisi değişmez. Önceki dersin kurgu kapsama ızgarası aynı tohumla üretilir: 12x12 hücre, yüzde 9 etkinlik, etiket olarak bitişik üç hücrelik bir hat. Bölme 200/100/200, sınamada en sık sınıf 0,5850.
• MI11. En büyük havuzlama, $p \times p$’lik ayrık pencerelerin her birini o penceredeki en büyük değere indirir. Ortalama havuzlama aynı pencereyi ortalamaya indirir. İkisi de öğrenilecek parametre taşımaz.
• MI12. Havuzlama, adımı pencere boyuna eşit bir indirgemedir; çıktı boyu $12/p$’dir. Pencere boyu 12’ye çıktığında geriye tek sayı kalır; bu uç duruma genel havuzlama denir.
• MI13. Geri kurulabilirlik sayılır. İkili bir ızgarada en büyük havuzlama sıfır veren pencerenin bütün hücrelerini belirler, bir veren pencerenin hiçbirini belirlemez. Geriye kalan belirsizlik, aynı havuzlanmış çıktıyı verebilecek özgün ızgara sayısının ikili logaritmasıdır.
• MI14. Havuzlama nereye uygulandığı önemlidir. Ham ızgaraya uygulanan havuzlama ile evrişim çıktısına — öznitelik haritasına — uygulanan havuzlama aynı işlem, farklı sonuçtur.
• MI15. Kaydırmaya dayanıklılık, ızgara bir hücre kaydırıldığında gösterimin aynen korunduğu örnek oranıdır. Haritası tümüyle sıfır olan ızgaralar bu ölçünün dışında bırakılır, çünkü onlarda kaydırma zaten hiçbir şeyi değiştirmez.
• MI16. Kaydırma bir hücre aşağıdır; en üste sıfır satırı eklenir, en alt satır düşer. Hattın alt kenarda olduğu ızgaralarda bilgi gerçekten kaybolur; bu, ölçünün parçasıdır.
• MI17. Kütüphane çağrılmaz; havuzlama, evrişim ve eğitim döngüsü ders içinde yazılır ve modeldir.
• MI18. Her ağ iki kez koşulur; ikinci koşumda yalnız başlangıç değerleri değişir.

Havuzlama Neyi Atıyor

# havuzlama.py — MODELDIR. 01'in KURGU kapsama izgarasi ayni tohumla uretilir.
import math

TOHUM, M32, BOY = 20260218, 0xFFFFFFFF, 12
YOGUNLUK, IZ_ORANI, KOSU = 0.09, 0.42, 3


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 izgara(no):
    r = uretec(TOHUM + 300000 + no)
    g = [[1 if r() < YOGUNLUK else 0 for _ in range(BOY)] for _ in range(BOY)]
    iz = 1 if r() < IZ_ORANI else 0
    if iz:
        yatay, a, b = r() < 0.5, int(r() * BOY), int(r() * (BOY - KOSU + 1))
        for k in range(KOSU):
            if yatay:
                g[a][b + k] = 1
            else:
                g[b + k][a] = 1
    return g, iz


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


HAM = [izgara(i) for i in range(500)]
VERI = [HAM[i] for i in karistir(500, TOHUM + 90000)]
EGT, SIN = VERI[:200], VERI[300:]
TABAN = max(sum(e for _, e in SIN), len(SIN) - sum(e for _, e in SIN)) / len(SIN)


def havuzla(m, p, ortalama=False):
    n = len(m) // p
    return [[(sum(m[i * p + a][j * p + b] for a in range(p) for b in range(p)) / (p * p)
              if ortalama else
              max(m[i * p + a][j * p + b] for a in range(p) for b in range(p)))
             for j in range(n)] for i in range(n)]


def hat_var(m, k):
    n = len(m)
    for i in range(n):
        for j in range(n - k + 1):
            if all(m[i][j + t] > 0 for t in range(k)) or \
               all(m[j + t][i] > 0 for t in range(k)):
                return True
    return False


print(f"{'pencere':>8}{'cikti':>8}{'hucre':>7}{'atilan':>8}"
      f"{'geri kurulan':>14}{'olasi izgara (log2)':>21}")
for p in (1, 2, 3, 4):
    n = BOY // p
    kuru, belirsiz = 0, 0
    for g, e in VERI:
        s = sum(sum(r) for r in havuzla(g, p))
        kuru += (n * n - s) * p * p + (s * p * p if p == 1 else 0)
        belirsiz += s
    kuru, belirsiz = kuru / len(VERI), belirsiz / len(VERI)
    print(f"{f'{p}x{p}':>8}{f'{n}x{n}':>8}{n * n:>7}{BOY * BOY - n * n:>8}"
          f"{kuru:>13.1f} {belirsiz * math.log2(2 ** (p * p) - 1):>20.1f}")

print(f"\n{'havuzlama':>10}{'aranan hat':>12}{'etiketle uyusma':>17}")
for p, k in ((1, 3), (2, 2), (3, 2)):
    u = sum(1 for g, e in VERI if hat_var(havuzla(g, p), k) == (e == 1))
    print(f"{('yok' if p == 1 else f'{p}x{p}'):>10}{k:>12}{u / len(VERI):>17.4f}")
print(f"taban cizgisi (sinamada en sik sinif) {TABAN:.4f}")

gercek = sum(sum(sum(r) for r in g) for g, _ in VERI) / len(VERI)
enb = sum(sum(sum(r) for r in havuzla(g, 2)) for g, _ in VERI) / len(VERI)
ort = sum(sum(sum(r) for r in havuzla(g, 2, True)) * 4 for g, _ in VERI) / len(VERI)
print(f"etkin hucre sayisi {gercek:.2f}; 2x2 en buyuk havuzlamadan okunan alt "
      f"sinir {enb:.2f}, ortalama havuzlamadan okunan {ort:.2f}")

 pencere   cikti  hucre  atilan  geri kurulan  olasi izgara (log2)
     1x1   12x12    144       0        144.0                  0.0
     2x2     6x6     36     108         96.9                 46.0
     3x3     4x4     16     128         60.0                 84.0
     4x4     3x3      9     135         30.8                113.2

 havuzlama  aranan hat  etiketle uyusma
       yok           3           0.9380
       2x2           2           0.4220
       3x3           2           0.4060
taban cizgisi (sinamada en sik sinif) 0.5850
etkin hucre sayisi 13.96; 2x2 en buyuk havuzlamadan okunan alt sinir 11.78, ortalama havuzlamadan okunan 13.96

İlk tablo atmanın büyüklüğünü veriyor. 2x2 pencere 144 hücreyi 36’ya indirir; 108 hücre gitmiştir. Gidenlerin hepsi geri kurulamaz değildir: sıfır veren bir pencere dört hücresinin de sıfır olduğunu söyler, bu yüzden ortalama 96,9 hücrenin değeri belirlidir. Belirsiz kalan pay ise 46,0 bittir — aynı havuzlanmış çıktıyı veren $2^{46}$ mertebesinde özgün ızgara vardır. Pencere 4x4’e çıktığında belirsizlik 113,2 bite yükselir ve geri kurulan hücre 30,8’e düşer.

İkinci tablo asıl uyarıdır. Ham ızgarada üç hücrelik hat aranınca uyuşma 0,9380’dir. Aynı ızgara 2x2 havuzlanıp iki hücrelik hat aranınca uyuşma 0,4220‘ye düşer, yani taban çizgisi 0,5850’nin altına. Havuzlama ham girdiye uygulandığında gürültü hücreleri birbirine yaklaşıp sahte hatlar üretir ve gerçek hat ile rastlantı ayırt edilemez hale gelir. Havuzlama burada bilgi atmakla kalmaz, ayırt edici bilgiyi tam olarak atar.

Son satır iki havuzlama türünün farkını veriyor. Ortalama havuzlamadan etkin hücre sayısı tam olarak geri okunur: 13,96. En büyük havuzlamadan okunan yalnız bir alt sınırdır, 11,78. Ortalama havuzlama sayıyı korur, en büyük havuzlama varlığı korur; hangisinin işe yaradığı sorulan soruya bağlıdır.

Öznitelik Haritasında Havuzlama

# harita.py — havuzlama ham izgaraya degil, evrisimin urettigi OZNITELIK
# HARITASINA uygulanir. Cekirdekler 01'in elle yazilmis cekirdekleridir.
DOLGU = 1
YATAY = [[0, 0, 0], [1, 1, 1], [0, 0, 0]]
DIKEY = [[0, 1, 0], [0, 1, 0], [0, 1, 0]]


def etkinler(g):
    return [(i, j) for i in range(BOY) for j in range(BOY) if g[i][j]]


def evris(ak, K, yanma):
    n = BOY + 2 * DOLGU - 3 + 1
    cikti = [[yanma] * n for _ in range(n)]
    for (i, j) in ak:
        for di in range(3):
            for dj in range(3):
                p, q = i + DOLGU - di, j + DOLGU - dj
                if 0 <= p < n and 0 <= q < n:
                    cikti[p][q] += K[di][dj]
    return cikti


def gosterim(g, p):
    ak, d = etkinler(g), []
    for K in (YATAY, DIKEY):
        m = [[max(0.0, v) for v in s] for s in evris(ak, K, -2.5)]
        d += [v for s in (havuzla(m, p) if p > 1 else m) for v in s]
    return d


def kaydir(g):                               # bir hucre asagi kaydirma
    return [[0] * BOY] + [s[:] for s in g[:-1]]


ETKIN = [g for g, e in SIN if any(v > 0 for v in gosterim(g, 1))]
print(f"haritasi tumuyle sifir olmayan sinama izgarasi {len(ETKIN)}/{len(SIN)}")
print(f"{'havuzlama':>10}{'harita':>9}{'bas girdisi':>12}{'bas param':>11}"
      f"{'toplam param':>14}{'kaydirmada ayni':>17}")
for p in (1, 2, 3, 12):
    n = BOY // p
    bas = 2 * n * n
    ayni = sum(1 for g in ETKIN
               if all(abs(x - y) < 1e-9 for x, y in
                      zip(gosterim(g, p), gosterim(kaydir(g), p))))
    print(f"{('yok' if p == 1 else f'{p}x{p}'):>10}{f'{n}x{n}':>9}{bas:>12}"
          f"{bas + 1:>11}{20 + bas + 1:>14}{ayni / len(ETKIN):>16.1%}")

haritasi tumuyle sifir olmayan sinama izgarasi 97/200
 havuzlama   harita bas girdisi  bas param  toplam param  kaydirmada ayni
       yok    12x12         288        289           309            0.0%
       2x2      6x6          72         73            93           38.1%
       3x3      4x4          32         33            53           55.7%
     12x12      1x1           2          3            23           88.7%

Aynı işlem, farklı yer, ters sonuç. Havuzlama evrişimin çıktısına uygulandığında hat bilgisi kaybolmaz, çünkü çekirdek hattı zaten bulmuştur; haritada kalan bilgi hattın yeri ve gücüdür, havuzlama yalnız yeri kabalaştırır.

Kazanç son sütunda. Havuzlamasız gösterimde bir hücrelik kaydırma haritayı her ızgarada değiştirir: dayanıklılık yüzde 0,0’dır. 2x2 havuzlamada gösterim ızgaraların yüzde 38,1‘inde aynen korunur, 3x3’te yüzde 55,7’de, genel havuzlamada yüzde 88,7’de. Sebep sayılabilir bir şeydir: en büyük değer pencerenin içinde yer değiştirdiği sürece pencerenin çıktısı değişmez, yani havuzlama pencere boyu kadar kaydırmayı yutar.

Kalan yüzde 11,3 kaydırmanın gerçekten bilgi götürdüğü paydır: hat en alt satırdaysa kaydırma onu ızgaranın dışına atar. Ortadaki üç sütun bedeli yazıyor — başın girdisi 288’den 2’ye, toplam parametre 309’dan 23’e düşüyor.

Üç Havuzlama, Üç Ağ

Şimdiye kadarki çekirdekler elle yazılmıştı. Aşağıda çekirdekler öğrenilir ve tek değişen şey havuzlama penceresidir.

# egit.py — MODELDIR: cekirdekler ogrenilir, havuzlama penceresi degisir.
# Cikis sigmoit, kayip capraz duzensizlik, guncelleme ornek basina.
EGT_E = [(etkinler(g), e) for g, e in EGT]
SIN_E = [(etkinler(g), e) for g, e in SIN]
KAY_E = [(etkinler(kaydir(g)), e) for g, e in SIN]


def sig(z):
    return 1 / (1 + math.exp(-z)) if z > -30 else 0.0


def kur(sayi, p, tohum):
    r, n = uretec(tohum), BOY // p
    return [[[[(r() * 2 - 1) / 3 for _ in range(3)] for _ in range(3)]
             for _ in range(sayi)], [0.0] * sayi,
            [(r() * 2 - 1) / (sayi * n * n) ** 0.5 for _ in range(sayi * n * n)],
            [0.0], p]


def ileri(P, ak):
    Ks, b, v, c, p = P
    n, z, kayit, idx = BOY // p, c[0], [], 0
    for k, K in enumerate(Ks):
        m = evris(ak, K, b[k])
        for i in range(n):
            for j in range(n):
                en, ep, eq = m[i * p][j * p], i * p, j * p
                for a in range(p):
                    for t in range(p):
                        if m[i * p + a][j * p + t] > en:
                            en, ep, eq = m[i * p + a][j * p + t], i * p + a, j * p + t
                h = max(0.0, en)
                kayit.append((k, ep, eq, h))
                z += v[idx] * h
                idx += 1
    return kayit, sig(z)


def egit(P, veri, tur, gadim, tohum):
    r, n = uretec(tohum), len(veri)
    Ks, b, v, c, p = P
    for _ in range(tur):
        s = list(range(n))
        for i in range(n - 1, 0, -1):
            j = int(r() * (i + 1))
            s[i], s[j] = s[j], s[i]
        for idx in s:
            ak, y = veri[idx]
            kayit, cikis = ileri(P, ak)
            d = cikis - y
            D = [[[0.0] * BOY for _ in range(BOY)] for _ in Ks]
            for t, (k, ep, eq, h) in enumerate(kayit):
                if h > 0.0:
                    D[k][ep][eq] += d * v[t]
                v[t] -= gadim * d * h
            c[0] -= gadim * d
            for k in range(len(Ks)):
                b[k] -= gadim * sum(sum(s2) for s2 in D[k])
                for di in range(3):
                    for dj in range(3):
                        Ks[k][di][dj] -= gadim * sum(
                            D[k][i + DOLGU - di][j + DOLGU - dj] for (i, j) in ak
                            if 0 <= i + DOLGU - di < BOY and 0 <= j + DOLGU - dj < BOY)
    return P


def dogruluk(P, veri):
    return sum(1 for ak, y in veri if (ileri(P, ak)[1] >= 0.5) == (y == 1)) / len(veri)


print(f"{'havuzlama':>10}{'param':>7}{'kosum':>7}{'egitim':>8}{'sinama':>8}"
      f"{'kaydirmada degisen karar':>26}")
print(f"{'taban':>10}{0:>7}{'-':>7}{'-':>8}{TABAN:>8.4f}{'-':>26}")
for p in (1, 2, 12):
    for k, tohum in enumerate((TOHUM + 11, TOHUM + 12)):
        P = egit(kur(2, p, tohum), EGT_E, 25, 0.05, tohum + 500)
        dev = sum(1 for (a1, y), (a2, _) in zip(SIN_E, KAY_E)
                  if (ileri(P, a1)[1] >= 0.5) != (ileri(P, a2)[1] >= 0.5))
        print(f"{('yok' if p == 1 else f'{p}x{p}') if k == 0 else '':>10}"
              f"{(20 + 2 * (BOY // p) ** 2 + 1) if k == 0 else '':>7}{k + 1:>7}"
              f"{dogruluk(P, EGT_E):>8.4f}{dogruluk(P, SIN_E):>8.4f}{dev:>26d}")

 havuzlama  param  kosum  egitim  sinama  kaydirmada degisen karar
     taban      0      -       -  0.5850                         -
       yok    309      1  1.0000  0.5150                        84
                       2  1.0000  0.5350                        88
       2x2     93      1  0.8950  0.6100                        49
                       2  0.7900  0.6150                        31
     12x12     23      1  0.8250  0.8050                        12
                       2  0.8200  0.8050                        11

Üç sayı tablonun içinde duruyor. Taban çizgisi 0,5850. Havuzlamasız ağ 309 parametreyle eğitim kümesini tamamen ezberliyor ve sınamada 0,5150 okuyor — tabanın altında. 2x2 havuzlamalı ağ 93 parametreyle 0,6100, genel havuzlamalı ağ 23 parametreyle 0,8050 okuyor. Havuzlama arttıkça ağ küçülüyor ve ayrılmış küme sayısı yükseliyor.

Son sütun aynı sırayı bağımsız bir ölçüyle doğruluyor. 200 sınama ızgarası bir hücre aşağı kaydırıldığında havuzlamasız ağın kararı 84 örnekte değişiyor, 2x2 havuzlamalıda 49, genel havuzlamalıda 12. Kaydırma etiketi değiştirmiyor.

İkinci koşum üç satırda da yazılıdır ve en çok 2x2 havuzlamada konuşuyor: iki koşumun sınama sayıları 0,6100 ile 0,6150, yani birbirine yakın, ama eğitim sayıları 0,8950 ile 0,7900 ve kaydırmada değişen karar 49 ile 31. Aynı kapasitenin iki koşumu ayrılmış kümede benzer bir sayı verirken kararın kaydırmaya karşı davranışında on sekiz örneklik fark açıyor. Ayrılmış küme sayısı bu farkı hiçbir biçimde bildirmiyor.

Özet

• 2x2 en büyük havuzlama 144 hücreyi 36’ya indirir; ortalama 96,9 hücre geri kurulabilir, geriye 46,0 bitlik belirsizlik kalır ve pencere 4x4’te belirsizlik 113,2 bite çıkar.
• Ham ızgaraya uygulanan havuzlama hat bilgisini yok eder: uyuşma 0,9380’den 0,4220’ye, yani taban çizgisinin altına düşer.
• Ortalama havuzlama etkin hücre sayısını tam olarak korur (13,96), en büyük havuzlama yalnız bir alt sınır verir (11,78).
• Aynı havuzlama öznitelik haritasına uygulandığında kaydırmaya dayanıklılık yüzde 0,0’dan yüzde 38,1’e, genel havuzlamada yüzde 88,7’ye çıkar; bedeli baş girdisinin 288’den 2’ye inmesidir.
• Taban çizgisi 0,5850 iken havuzlamasız ağ 309 parametreyle 0,5150 ve 0,5350, 2x2 havuzlamalı ağ 93 parametreyle 0,6100 ve 0,6150, genel havuzlamalı ağ 23 parametreyle 0,8050 ve 0,8050 okur.
• Kaydırılan sınama kümesinde değişen karar sayısı 84, 49 ve 12’dir; 2x2 havuzlamanın iki koşumu aynı sınama sayısını verirken bu sayıda 49 ile 31 arasında ayrışır.

Sonraki Adım

Buraya kadarki ağ iki katmanlıdır: bir evrişim, bir havuzlama, bir doğrusal baş. Genel havuzlama en iyi sayıyı verdi, ama hattın yerini tümüyle attı — bu ağ “iki hat var mı” sorusunu yanıtlayamaz. Bunun yolu haritayı bir kerede sıfıra indirmek yerine evrişim ve havuzlamayı sırayla yığmaktır: her katman bir öncekinin çıktısında daha büyük bir alanı görür. Sonraki ders bu yığmanın bedelini ölçer: katman sayısı arttıkça çıkıştan gelen eğimin ilk katmana ulaşıp ulaşmadığı sayılır, atlamalı bağlantının bunu ne kadar düzelttiği ölçülür ve daha derin bir ağın daha sığ bir ağı geçemediği bir nokta gösterilir.