Evrişimli Ağ Mimarileri

Önceki iki ders tek bir evrişim katmanı kullandı. O katman 3x3’lük bir pencereden bakar ve ızgaranın yalnız o kadarını görür; “iki hat birbirine yakın mı” gibi bir soruyu yanıtlaması için daha geniş bir alana bakması gerekir. Bunun yolu çekirdeği büyütmek değil, katmanları yığmaktır: ikinci katman birincinin çıktısında 3x3’e bakar ve dolaylı olarak girdide çok daha büyük bir alanı görür.

Yığmanın bir bedeli vardır ve bu dersin ölçüsü odur. Kayıptan gelen eğim, çıkıştan başlayıp katman katman geriye taşınır; her katman onu bir kez daha çarpar. Yığın derinleştikçe ilk katmana ulaşan eğim küçülür ve bir noktadan sonra ilk katman hiç güncellenmez. Ölçülecek üç şey vardır: derinlikle büyüyen görme alanı, ilk katmana ulaşan eğimin büyüklüğü ve derinliğin ayrılmış küme sayısına kattığı fark.

• MI19. Küme, bölme ve taban çizgisi değişmez. Kurgu kapsama ızgarası aynı tohumla üretilir; bölme 200/100/200, sınamada en sık sınıf 0,5850.
• MI20. Yığın sabittir, değişen tek şey blok sayısıdır. Katman 0: iki 3x3 çekirdek, dolgu 1, doğrultulmuş doğrusal birim, ardından 4x4 havuzlama — geriye kanal başına 3x3 harita kalır. Sonra $D$ blok, sonra genel havuzlama ve doğrusal baş.
• MI21. Blok, bir kanalın haritasına uygulanan 3x3 evrişim ve doğrultulmuş doğrusal birimdir; kanallar birbirine karışmaz.
• MI22. Atlamalı bağlantı, bloğun girdisini çıktısına eklemektir. Blok artık girdiyi değiştirmez, girdiye bir düzeltme öğrenir; eğim geriye iki yoldan gider ve biri hiçbir çarpanla küçülmez.
• MI23. Görme alanı, bir çıktı biriminin değerini etkileyebilen girdi hücrelerinin oluşturduğu karenin kenar uzunluğudur. Havuzlama penceresi 4, blok başına genişleme 2 pencere olduğundan kenar $4(2D+1)+2$’dir.
• MI24. Eğim ölçümü ilklendirmede yapılır ve 80 eğitim ızgarasında ortalanır; ölçülen sayı ilk katmanın çekirdek eğimlerinin mutlak değer toplamıdır. Sorulan şey, eğitimin başlayıp başlayamayacağıdır.
• MI25. İlklendirme sabittir ve kazanç ölçekli değildir: bütün çekirdek ağırlıkları aynı aralıktan çekilir, böylece derinlikle ne olduğu görülebilir.
• MI26. Kütüphane çağrılmaz; yığın, ileri geçiş, geri yayılım ve eğitim döngüsü ders içinde yazılır ve modeldir. Hiçbir mimari bir kişi ya da kurum adıyla anılmaz; yapı adıyla anılır.
• MI27. Her ağ iki kez koşulur; ikinci koşumda yalnız başlangıç değerleri değişir.

Yığın ve Görme Alanı

# mimari.py — MODELDIR. 01'in KURGU kapsama izgarasi ayni tohumla uretilir.
# Yigin: evrisim(3x3, dolgu 1, iki cekirdek) -> ReLU -> havuzlama 4x4 -> 3x3
# harita; ardindan D blok (her kanala 3x3 evrisim + ReLU, atlamali surumde
# blogun girdisi ciktiya eklenir); sonra genel havuzlama ve dogrusal bas.
import math

TOHUM, M32, BOY = 20260218, 0xFFFFFFFF, 12
YOGUNLUK, IZ_ORANI, KOSU = 0.09, 0.42, 3
DOLGU, KUCUK, YAN, KANAL = 1, 4, 3, 2


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_E = [([(i, j) for i in range(BOY) for j in range(BOY) if g[i][j]], e)
         for g, e in VERI[:200]]
SIN_E = [([(i, j) for i in range(BOY) for j in range(BOY) if g[i][j]], e)
         for g, e in VERI[300:]]
TABAN = max(sum(e for _, e in SIN_E), len(SIN_E) - sum(e for _, e in SIN_E)) / len(SIN_E)


def kur(D, tohum, a=1 / 3):
    r = uretec(tohum)
    return [[[[[(r() * 2 - 1) * a for _ in range(3)] for _ in range(3)]
              for _ in range(KANAL)] for _ in range(D + 1)],
            [[0.0] * KANAL for _ in range(D + 1)],
            [(r() * 2 - 1) * 0.5 for _ in range(KANAL)], [0.0], D]


def ileri(P, ak, atlama):
    Ks, bs, v, c, D = P
    x, hav = [], []
    for k in range(KANAL):                   # katman 0: seyrek girdide evrisim
        m = [[bs[0][k]] * BOY for _ in range(BOY)]
        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 < BOY and 0 <= q < BOY:
                        m[p][q] += Ks[0][k][di][dj]
        kh, kx = [], [[0.0] * YAN for _ in range(YAN)]
        for i in range(YAN):
            for j in range(YAN):
                en, ep, eq = None, 0, 0
                for a in range(KUCUK):
                    for b in range(KUCUK):
                        u = m[i * KUCUK + a][j * KUCUK + b]
                        if en is None or u > en:
                            en, ep, eq = u, i * KUCUK + a, j * KUCUK + b
                kx[i][j] = max(0.0, en)
                kh.append((ep, eq, en))
        x.append(kx)
        hav.append(kh)
    ara, icler = [x], []
    for t in range(1, D + 1):                # D blok
        xp, yeni, ic = ara[-1], [], []
        for k in range(KANAL):
            z = [[bs[t][k]] * YAN for _ in range(YAN)]
            for p in range(YAN):
                for q in range(YAN):
                    s = bs[t][k]
                    for di in range(3):
                        i2 = p + di - DOLGU
                        if 0 <= i2 < YAN:
                            xi = xp[k][i2]
                            for dj in range(3):
                                j2 = q + dj - DOLGU
                                if 0 <= j2 < YAN:
                                    s += Ks[t][k][di][dj] * xi[j2]
                    z[p][q] = s
            ic.append(z)
            yeni.append([[max(0.0, z[i][j]) + (xp[k][i][j] if atlama else 0.0)
                          for j in range(YAN)] for i in range(YAN)])
        icler.append(ic)
        ara.append(yeni)
    son, h, arg = ara[-1], [], []
    for k in range(KANAL):                   # genel havuzlama
        en, ep, eq = son[k][0][0], 0, 0
        for i in range(YAN):
            for j in range(YAN):
                if son[k][i][j] > en:
                    en, ep, eq = son[k][i][j], i, j
        h.append(en)
        arg.append((ep, eq))
    z = c[0] + sum(v[k] * h[k] for k in range(KANAL))
    return 1 / (1 + math.exp(-max(-30, min(30, z)))), (hav, ara, icler, h, arg)


print(f"sinamada en sik sinif {TABAN:.4f}; egitim {len(EGT_E)} izgara")
print(f"{'derinlik':>9}{'blok':>6}{'parametre':>11}{'gorme alani':>13}"
      f"{'kapsanan izgara':>17}")
for D in (0, 1, 2, 3, 5, 8):
    alan = KUCUK * (2 * D + 1) + 2
    print(f"{D:>9}{D:>6}{20 * (D + 1) + 3:>11}{f'{alan}x{alan}':>13}"
          f"{min(alan, BOY) ** 2 / (BOY * BOY):>16.1%}")

sinamada en sik sinif 0.5850; egitim 200 izgara
 derinlik  blok  parametre  gorme alani  kapsanan izgara
        0     0         23          6x6           25.0%
        1     1         43        14x14          100.0%
        2     2         63        22x22          100.0%
        3     3         83        30x30          100.0%
        5     5        123        46x46          100.0%
        8     8        183        70x70          100.0%

Görme alanı derinlikle doğrusal büyür ve bir blokta doyar: derinlik 0’da bir çıktı birimi ızgaranın yüzde 25’ini görürken derinlik 1’de kenar 14 hücreye çıkıp 12’lik ızgarayı aşar. Sonraki bloklar hiçbir yeni girdi hücresi getirmez, yalnız parametre ekler. Burada derinlikten beklenecek kazanç görme alanından gelemez.

Eğim İlk Katmana Ulaşıyor mu

# egim.py — geri yayilim elle yazilir. Olculen sey: cikistan gelen egimin ILK
# katmanin cekirdeklerine ne kadari ulasiyor. Olcum ILKLENDIRMEDE yapilir.
def geri(P, ak, ic, d, atlama):
    Ks, bs, v, c, D = P
    hav, ara, icler, h, arg = ic
    dv = [d * h[k] for k in range(KANAL)]
    delta = [[[0.0] * YAN for _ in range(YAN)] for _ in range(KANAL)]
    for k in range(KANAL):
        ep, eq = arg[k]
        delta[k][ep][eq] = d * v[k]
    dK = [[[[0.0] * 3 for _ in range(3)] for _ in range(KANAL)] for _ in range(D + 1)]
    db = [[0.0] * KANAL for _ in range(D + 1)]
    for t in range(D, 0, -1):
        xp, ic2 = ara[t - 1], icler[t - 1]
        yeni = [[[delta[k][i][j] if atlama else 0.0 for j in range(YAN)]
                 for i in range(YAN)] for k in range(KANAL)]
        for k in range(KANAL):
            z = ic2[k]
            for p in range(YAN):
                for q in range(YAN):
                    g = delta[k][p][q] if z[p][q] > 0 else 0.0
                    if g == 0.0:
                        continue
                    db[t][k] += g
                    for di in range(3):
                        i2 = p + di - DOLGU
                        if not 0 <= i2 < YAN:
                            continue
                        for dj in range(3):
                            j2 = q + dj - DOLGU
                            if 0 <= j2 < YAN:
                                dK[t][k][di][dj] += g * xp[k][i2][j2]
                                yeni[k][i2][j2] += g * Ks[t][k][di][dj]
        delta = yeni
    for k in range(KANAL):
        d0 = [[0.0] * BOY for _ in range(BOY)]
        t2 = 0
        for i in range(YAN):
            for j in range(YAN):
                ep, eq, en = hav[k][t2]
                t2 += 1
                if en > 0 and delta[k][i][j] != 0.0:
                    d0[ep][eq] += delta[k][i][j]
        for di in range(3):
            for dj in range(3):
                dK[0][k][di][dj] = sum(
                    d0[i + DOLGU - di][j + DOLGU - dj] for (i, j) in ak
                    if 0 <= i + DOLGU - di < BOY and 0 <= j + DOLGU - dj < BOY)
        db[0][k] = sum(sum(s) for s in d0)
    return dK, db, dv


print(f"{'derinlik':>9}{'duz ilk katman':>17}{'atlamali ilk katman':>21}"
      f"{'oran':>12}")
for D in (0, 1, 2, 3, 5, 8):
    olcu = []
    for atlama in (False, True):
        P, tot = kur(D, TOHUM + 11), 0.0
        for ak, y in EGT_E[:80]:
            cikis, ic = ileri(P, ak, atlama)
            dK = geri(P, ak, ic, cikis - y, atlama)[0]
            tot += sum(abs(u) for k in range(KANAL) for s in dK[0][k] for u in s)
        olcu.append(tot / 80)
    print(f"{D:>9}{olcu[0]:>17.3e}{olcu[1]:>21.3e}{olcu[1] / olcu[0]:>12.1f}")

 derinlik   duz ilk katman  atlamali ilk katman        oran
        0        6.405e-01            6.405e-01         1.0
        1        2.393e-02            8.261e-01        34.5
        2        2.729e-03            1.925e-01        70.6
        3        2.457e-03            7.907e-01       321.8
        5        1.984e-04            1.043e+00      5256.1
        8        9.269e-07            6.779e-01    731349.2

Düz yığında ilk katmana ulaşan eğim derinlik 0’da $6{,}405 \times 10^{-1}$’dir. Bir blok onu $2{,}393 \times 10^{-2}$’ye, beş blok $1{,}984 \times 10^{-4}$’e, sekiz blok $9{,}269 \times 10^{-7}$’ye indiriyor — yaklaşık yedi yüz bin kat. Bu bir eğitim kusuru değil, çarpımın kendisidir: her blok geriye giden eğimi ağırlıklarıyla bir kez daha çarpar ve çarpanlar birden küçükse çarpım derinlikle üstel küçülür.

Atlamalı bağlantı sütunu aynı derinliklerde $1{,}9 \times 10^{-1}$ ile $1{,}0$ arasında kalıyor; derinlikle azalmıyor. Sebep MI22’de yazılıdır: bloğun çıktısı girdisini içerdiği için eğimin geriye giden bir kopyası hiçbir çekirdekle çarpılmaz ve olduğu gibi taşınır. Oran sütunu düzeltmenin büyüklüğüdür — derinlik 2’de 70,6 kat, derinlik 8’de 731.349 kat.

Derinliğin Kattığı

# egit.py — MODELDIR: ayni veri, ayni tur butcesi, ayni ogrenme adimi.
# Degisen yalniz derinlik ve atlamali baglantinin varligi.
def egit(P, veri, tur, gadim, tohum, atlama):
    r, n = uretec(tohum), len(veri)
    Ks, bs, v, c, D = 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]
            cikis, ic = ileri(P, ak, atlama)
            d = cikis - y
            dK, db, dv = geri(P, ak, ic, d, atlama)
            for t in range(D + 1):
                for k in range(KANAL):
                    bs[t][k] -= gadim * db[t][k]
                    for di in range(3):
                        for dj in range(3):
                            Ks[t][k][di][dj] -= gadim * dK[t][k][di][dj]
            for k in range(KANAL):
                v[k] -= gadim * dv[k]
            c[0] -= gadim * d
    return P


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


print(f"{'derinlik':>9}{'baglanti':>10}{'param':>7}{'kosum':>7}{'egitim':>8}"
      f"{'sinama':>8}{'tabana gore':>13}")
print(f"{'taban':>9}{'-':>10}{0:>7}{'-':>7}{'-':>8}{TABAN:>8.4f}{'0.0000':>13}")
for D, atlama in ((0, False), (2, False), (2, True), (5, False), (5, True)):
    for k, tohum in enumerate((TOHUM + 11, TOHUM + 12)):
        P = egit(kur(D, tohum), EGT_E, 25, 0.05, tohum + 500, atlama)
        s = dogruluk(P, SIN_E, atlama)
        print(f"{D if k == 0 else '':>9}"
              f"{('atlamali' if atlama else 'duz') if k == 0 else '':>10}"
              f"{(20 * (D + 1) + 3) if k == 0 else '':>7}{k + 1:>7}"
              f"{dogruluk(P, EGT_E, atlama):>8.4f}{s:>8.4f}{s - TABAN:>+13.4f}")

 derinlik  baglanti  param  kosum  egitim  sinama  tabana gore
    taban         -      0      -       -  0.5850       0.0000
        0       duz     23      1  0.8100  0.7850      +0.2000
                                2  0.8200  0.8050      +0.2200
        2       duz     63      1  0.5950  0.5850      +0.0000
                                2  0.5950  0.5850      +0.0000
        2  atlamali     63      1  0.8350  0.7950      +0.2100
                                2  0.8150  0.8150      +0.2300
        5       duz    123      1  0.5950  0.5850      +0.0000
                                2  0.5950  0.5850      +0.0000
        5  atlamali    123      1  0.8400  0.8150      +0.2300
                                2  0.9000  0.8900      +0.3050

Tablonun ortasındaki iki satır bu kursun ikinci iddiasının bu derste aldığı biçimdir ve saklanmaz: daha derin ağ daha sığ ağı geçemedi. 23 parametreli sığ ağ 0,7850 ve 0,8050 okuyor; 63 parametreli, üç kat daha derin düz ağ iki koşumda da 0,5850 okuyor, yani tam olarak taban çizgisini. Beş bloklu düz ağ 123 parametreyle aynı yerde. Bu ağlar eğitim kümesinde de 0,5950’de kalıyor; öğrenmemişler, ezberlememişler de. Önceki tablo nedenini yazıyor: ilk katmana ulaşan eğim $2{,}7 \times 10^{-3}$ ve $2{,}0 \times 10^{-4}$’tür, yani ilk katman ilklendirildiği yerde kalmıştır ve ondan sonraki her şey rastgele bir haritanın üzerine kuruludur.

Atlamalı bağlantı aynı derinliği çalışır hale getiriyor: derinlik 2’de 0,7950 ve 0,8150, derinlik 5’te 0,8150 ve 0,8900. Yapı değişmedi, parametre sayısı değişmedi, tek fark bloğun girdisinin çıktısına eklenmesi.

Son karşılaştırma dikkatle okunmalı. Sığ ağın iki koşumunun ortalaması 0,7950, beş bloklu atlamalı ağınki 0,8525; derinliğin kattığı görünen fark 0,0575. Ama beş bloklu ağın iki koşumu 0,8150 ile 0,8900 arasında, aralık 0,0750. Derinliğin kattığı fark, aynı ağın yalnız başlangıç değerleri değişerek verdiği farktan küçüktür; tek koşumla yapılan bir karşılaştırma bu ağı sığ ağın hem 0,0850 hem 0,0100 üstünde gösterebilirdi.

Özet

• Görme alanı derinlikle doğrusal büyür ve bu ızgarada bir blokta doyar: derinlik 0’da yüzde 25, derinlik 1’de yüzde 100. Sonraki bloklar yeni girdi hücresi getirmez, yalnız parametre ekler.
• Düz yığında ilk katmana ulaşan eğim derinlik 0’da $6{,}405 \times 10^{-1}$, derinlik 8’de $9{,}269 \times 10^{-7}$’dir; küçülme çarpımın kendisinden gelir.
• Atlamalı bağlantı aynı derinliklerde eğimi $1{,}9 \times 10^{-1}$ ile $1{,}0$ arasında tutar; düzeltme oranı derinlik 2’de 70,6, derinlik 8’de 731.349 kattır.
• Taban çizgisi 0,5850 iken 23 parametreli sığ ağ 0,7850 ve 0,8050 okur; 63 ve 123 parametreli düz derin ağlar iki koşumda da 0,5850’de kalır — daha derin ağ daha sığ ağı geçemez.
• Atlamalı bağlantı derinlik 2’de 0,7950 ve 0,8150, derinlik 5’te 0,8150 ve 0,8900 verir; parametre sayısı değişmeden.
• Derinliğin kattığı ortalama fark 0,0575, aynı ağın iki koşumu arasındaki fark 0,0750’dir; ikincisi büyük olduğu sürece birincisi tek koşumla ölçülemez.

Sonraki Adım

Üç derste girdinin yapısı uzamsaldı ve ızgaranın tamamı ağa bir kerede verildi; hangi hücrenin önce geldiği diye bir soru yoktu. Abonenin sayaç okumaları böyle değildir: okumalar bir sıra oluşturur, sıradaki yer anlamlıdır ve abone başına okuma sayısı aynı değildir. Sabit boyda bir pencereden bakan çekirdek, pencere dışında kalan geçmişi göremez. Sonraki ders girdiyi baştan sona adım adım okuyan ve gördüğünü bir gizli durumda biriktiren bir yapıyı kurar. Ölçülecek şey o durumun ne taşıdığıdır: dizinin başındaki bilgi, dizi uzadıkça durumda ne kadar kalıyor.