Evrişim İşlemi

Dokuz derste ağ tam bağlı kaldı: her girdi sütunu her birime kendi ağırlığıyla bağlandı. Böyle bir katmanda sütunların sırası hiçbir şey ifade etmez; sütunlar karıştırılsa ağın öğrendiği şey değişmez, yalnız ağırlıkların yeri değişir. Abone tablosunda bu bir kayıp değildir, çünkü hane sayısı ile ortalama tüketim arasında bir komşuluk yoktur.

Girdi bir ızgara olduğunda durum değişir. Aranan şey tek bir hücrede değil, birkaç bitişik hücrenin oluşturduğu düzendedir. Tam bağlı katman bunu kullanmaz: her hücre için ayrı bir ağırlık öğrenir ve aynı düzen başka bir yerde göründüğünde onu yeniden öğrenmek zorunda kalır. Bu dersin ölçüsü budur — aynı işi tam bağlı katman kaç ağırlıkla, evrişim kaç ağırlıkla yapıyor.

• MI1. Kapsama ızgarası kurgudur. M26/K06’da bölgeler 12x12’lik bir hücre ızgarasına bölünmüştü; burada aynı ızgara bir öğrenme girdisine çevrilir. Her hücre bir kapsama birimidir ve değeri, o birimde eşik üstü okuma bulunup bulunmadığıdır. Tohum 20260218.
• MI2. Etiket de kurgudur ve yapısaldır. Bir ızgara, içine bitişik üç hücrelik bir hat ekilmişse 1 etiketlidir. Hat, bir hattın boyunca ilerleyen kaçak izinin karşılığıdır; dağınık tekil hücreler ise gürültüdür.
• MI3. Etiket ızgaradan tam olarak okunamaz. Hücrelerin yaklaşık yüzde 9’u kendiliğinden etkindir; hat ekilmemiş bazı ızgaralarda da rastlantıyla üç hücrelik bir dizilim oluşur.
• MI4. Bölme 200/100/200’dür ve bu ızgara kümesinde sabittir. Eğitim kümesi bilerek küçültülmüştür; ölçek küçük tutulur.
• MI5. Taban çizgisi ızgara kümesinden okunur. Sınamada en sık sınıfı söylemek 0,5850 verir. M27/K01–K03’ün 0,7579’u abone tablosuna aittir ve bu kümeyle karşılaştırılamaz.
• MI6. Çekirdek, ızgara üzerinde kaydırılan küçük bir ağırlık dizeyidir; adım iki komşu konum arasındaki kayma, dolgu kenara eklenen sıfır çerçevesinin kalınlığıdır.
• MI7. Ağırlık paylaşımı evrişimin tanımıdır: aynı çekirdek bütün konumlarda kullanılır. Bu, parametre sayısını konum sayısından bağımsız kılar.
• MI8. Kütüphane çağrılmaz; evrişim ve eğitim döngüsü ders içinde yazılır ve modeldir.
• MI9. Her ağ iki kez koşulur. İkinci koşumda yalnız başlangıç değerleri değişir; veri, bölme, tur sayısı ve öğrenme adımı aynıdır.

Kapsama Izgarası ve Parametre Sayısı

# izgara.py — MODELDIR. Kapsama izgarasi KURGUDUR: M26/K06'nin 12x12'lik
# kapsama izgarasi burada bir ogrenme girdisine cevrilir. Her hucre bir
# kapsama birimidir ve degeri, o birimde esik ustu okuma olup olmadigidir.
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):
    """Bir abonenin kapsama izgarasi. Etiket: sizinti izi ekilmis mi."""
    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:                                   # bitisik uc hucrelik bir hat
        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, DOG, SIN = VERI[:200], VERI[200:300], VERI[300:]
TABAN = max(sum(e for _, e in SIN), len(SIN) - sum(e for _, e in SIN)) / len(SIN)

ornek = next(g for g, e in VERI if e == 1 and any(
    all(g[i][j + k] for k in range(KOSU))
    for i in range(BOY) for j in range(BOY - KOSU + 1)))
print("yatay hat ekilmis bir izgara (1 = esik ustu okuma), etiket 1:")
for satir in ornek:
    print("   " + "".join("#" if x else "." for x in satir))
print(f"izgara {BOY}x{BOY} = {BOY * BOY} hucre, ortalama etkin hucre "
      f"{sum(sum(sum(s) for s in g) for g, _ in VERI) / len(VERI):.2f}")
print(f"bolme {len(EGT)}/{len(DOG)}/{len(SIN)}, sinamada en sik sinif "
      f"{TABAN:.4f}")

TB_H = 8
tb_par = BOY * BOY * TB_H + TB_H + TB_H + 1
tam_katman = (BOY * BOY) ** 2 + BOY * BOY
print(f"\n{'katman':<34}{'agirlik':>9}{'yanma':>7}{'toplam':>9}")
print(f"{'tam bagli 144 -> 144':<34}{(BOY * BOY) ** 2:>9}{BOY * BOY:>7}"
      f"{tam_katman:>9}")
print(f"{'evrisim 3x3, tek cekirdek':<34}{9:>9}{1:>7}{10:>9}")
print(f"ayni cikti boyutu icin oran {tam_katman / 10:.0f} kat")

yatay hat ekilmis bir izgara (1 = esik ustu okuma), etiket 1:
   #..#........
   ....#.......
   ..#...#.....
   ............
   #.#.........
   .....#..#...
   #....#.....#
   .####....##.
   .......##...
   ..........#.
   ..........#.
   ............
izgara 12x12 = 144 hucre, ortalama etkin hucre 13.96
bolme 200/100/200, sinamada en sik sinif 0.5850

katman                              agirlik  yanma   toplam
tam bagli 144 -> 144                  20736    144    20880
evrisim 3x3, tek cekirdek                 9      1       10
ayni cikti boyutu icin oran 2088 kat

Örnek ızgarada yedinci satırdaki dört bitişik hücrenin üçü ekilmiş hattır, dördüncüsü rastlantıyla yanına düşmüş bir gürültü hücresidir. Geri kalan etkin hücreler dağınıktır.

Alt tablo dersin sayısıdır. Her hücre için bir çıktı üreten tam bağlı katman 20.880 sayı tutar. Aynı çıktı boyutunu üreten tek bir 3x3 çekirdek 10 sayı tutar: dokuz ağırlık ve bir yanma. Oran 2.088 kattır.

Fark bir eniyileme numarası değil, bir varsayımdır. Tam bağlı katman “her konumun kendi kuralı olabilir” der ve 144 ayrı kural için yer ayırır; evrişim “aranan düzen nerede olursa olsun aynı düzendir” der ve tek bir kural öğrenir. Varsayım yanlışsa evrişim öğrenemez. Bu ızgarada doğrudur, çünkü hat herhangi bir yere ekilir.

Çekirdek, Adım ve Dolgu

# evrisim.py — evrisim islemi elle yazilir: cekirdek izgara uzerinde kaydirilir
# ve her konumda ayni agirliklar kullanilir. Girdi ikili oldugu icin dongu
# yalniz etkin hucrelerden yurur; hesaplanan sayi degismez, kosum kisalir.
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, adim=1, dolgu=0):
    c = len(K)
    n = (BOY + 2 * dolgu - c) // adim + 1
    cikti = [[yanma] * n for _ in range(n)]
    for (i, j) in ak:
        for di in range(c):
            for dj in range(c):
                p, q = i + dolgu - di, j + dolgu - dj
                if p % adim == 0 and q % adim == 0 and 0 <= p // adim < n \
                        and 0 <= q // adim < n and p >= 0 and q >= 0:
                    cikti[p // adim][q // adim] += K[di][dj]
    return cikti


YATAY = [[0, 0, 0], [1, 1, 1], [0, 0, 0]]
DIKEY = [[0, 1, 0], [0, 1, 0], [0, 1, 0]]


def ates(g, dolgu):
    ak = etkinler(g)
    return (max(max(r) for r in evris(ak, YATAY, -2.5, 1, dolgu)) > 0
            or max(max(r) for r in evris(ak, DIKEY, -2.5, 1, dolgu)) > 0)


print("yatay cekirdek ciktisi (+ = hat bulundu), dolgu 1, 12x12:")
for satir in evris(etkinler(ornek), YATAY, -2.5, 1, 1):
    print("   " + "".join("+" if v > 0 else "." for v in satir))
for dolgu in (0, 1):
    u = sum(1 for g, e in VERI if ates(g, dolgu) == (e == 1))
    print(f"elle yazilmis iki cekirdek, dolgu {dolgu}: etiketle uyusma "
          f"{u / len(VERI):.4f}")

print(f"\n{'adim':>5}{'dolgu':>6}{'cikti':>8}{'agirlik':>9}{'carpma':>9}"
      f"{'tam bagli carpma':>18}")
for adim, dolgu in ((1, 0), (1, 1), (2, 0), (2, 1), (3, 1)):
    n = (BOY + 2 * dolgu - 3) // adim + 1
    print(f"{adim:>5}{dolgu:>6}{f'{n}x{n}':>8}{10:>9}{n * n * 9:>9}"
          f"{n * n * BOY * BOY:>18}")

yatay cekirdek ciktisi (+ = hat bulundu), dolgu 1, 12x12:
   ............
   ............
   ............
   ............
   ............
   ............
   ............
   ..++........
   ............
   ............
   ............
   ............
elle yazilmis iki cekirdek, dolgu 0: etiketle uyusma 0.8900
elle yazilmis iki cekirdek, dolgu 1: etiketle uyusma 0.9380

 adim dolgu   cikti  agirlik   carpma  tam bagli carpma
    1     0   10x10       10      900             14400
    1     1   12x12       10     1296             20736
    2     0     5x5       10      225              3600
    2     1     6x6       10      324              5184
    3     1     4x4       10      144              2304

Çekirdek elle yazıldığında ne yaptığı görünür olur. Yatay çekirdek üç bitişik hücrenin toplamını alır ve $-2,5$ yanmasıyla ancak üçü birden etkinse pozitif değer üretir; örnek ızgarada yedinci satırın iki konumunda ateş ediyor, çünkü orada dört bitişik hücre var. Bu iki çekirdek hiç eğitilmeden bütün kümede 0,9380 uyuşma veriyor.

İki uyuşma sayısı arasındaki fark dolgunun tek başına ölçüsüdür. Dolgusuz çalışıldığında çekirdeğin merkezi ilk ve son satıra oturamaz, kenardaki hatlar görülmez ve uyuşma 0,8900’e düşer. Bir sıra sıfır eklemek farkı 0,0480 kapatır; dolgu bir ayar kolaylığı değil, kenardaki bilgiyi görüp görmeme kararıdır.

Alttaki tablo çıktı boyutunun $n = \lfloor (12 + 2d - c)/s \rfloor + 1$ bağıntısıyla adım $s$, dolgu $d$ ve çekirdek boyu $c$ değerlerinden çıktığını gösteriyor. Dikkat edilecek sütun ağırlık sütunudur: adım ve dolgu ne olursa olsun 10’dur. Adım yalnız çarpma sayısını değiştirir — 1.296’dan 144’e. Tam bağlı katman her satırda on altı kat daha fazla çarpma yapar ve o çarpmaların her birinin ayrı bir ağırlığı vardır.

İki Ağ Yan Yana

Parametre sayısı bir vaattir; ayrılmış küme sayısı onun ne ettiğidir. İki ağ aynı veride, aynı bütçeyle eğitilir; tek fark ilk katmanın biçimidir.

# egit.py — MODELDIR: iki ag ayni veride, ayni tur butcesinde egitilir.
# Cikis sigmoit, kayip capraz duzensizlik, guncelleme ornek basina.
DOLGU, N = 1, BOY + 2 * 1 - 3 + 1
EGT_E = [(etkinler(g), e) for g, e in EGT]
SIN_E = [(etkinler(g), e) for g, e in SIN]


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


def tam_bagli(H, tohum):                     # 144 -> H -> 1
    r, a = uretec(tohum), (1 / (BOY * BOY)) ** 0.5
    return [[[(r() * 2 - 1) * a for _ in range(BOY * BOY)] for _ in range(H)],
            [0.0] * H, [(r() * 2 - 1) * (1 / H) ** 0.5 for _ in range(H)], [0.0]]


def tb_ileri(P, ak):
    W, b, v, c = P
    h = [max(0.0, b[k] + sum(W[k][i * BOY + j] for (i, j) in ak))
         for k in range(len(b))]
    return h, sig(c[0] + sum(v[k] * h[k] for k in range(len(h))))


def evrisimli(sayi, tohum):                  # sayi cekirdek -> en buyuk -> 1
    r, a = uretec(tohum), (1 / 9) ** 0.5
    return [[[[(r() * 2 - 1) * a for _ in range(3)] for _ in range(3)]
             for _ in range(sayi)], [0.0] * sayi,
            [(r() * 2 - 1) * (1 / sayi) ** 0.5 for _ in range(sayi)], [0.0]]


def ev_ileri(P, ak):
    Ks, b, v, c = P
    h, arg = [], []
    for k, K in enumerate(Ks):
        m = evris(ak, K, b[k], 1, DOLGU)
        en, ep, eq = m[0][0], 0, 0
        for p in range(N):
            for q in range(N):
                if m[p][q] > en:
                    en, ep, eq = m[p][q], p, q
        h.append(max(0.0, en))
        arg.append((ep, eq))
    return (h, arg), sig(c[0] + sum(v[k] * h[k] for k in range(len(h))))


def egit(P, ileri, veri, tur, gadim, tohum, evrisim):
    r, n = uretec(tohum), len(veri)
    W, b, v, c = 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]
            ic, p = ileri(P, ak)
            h = ic[0] if evrisim else ic
            d = p - y
            for k in range(len(b)):
                if h[k] > 0.0:
                    dh = d * v[k]
                    b[k] -= gadim * dh
                    if evrisim:
                        ep, eq = ic[1][k]
                        for (i, j) in ak:
                            di, dj = i + DOLGU - ep, j + DOLGU - eq
                            if 0 <= di < 3 and 0 <= dj < 3:
                                W[k][di][dj] -= gadim * dh
                    else:
                        for (i, j) in ak:
                            W[k][i * BOY + j] -= gadim * dh
                v[k] -= gadim * d * h[k]
            c[0] -= gadim * d
    return P


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


ev_par = 2 * (9 + 1) + 2 + 1
print(f"{'ag':<22}{'parametre':>10}{'kosum':>7}{'egitim':>8}{'sinama':>8}")
print(f"{'taban cizgisi':<22}{0:>10}{'-':>7}{'-':>8}{TABAN:>8.4f}")
for ad, kur, ileri, ev, par in (("tam bagli 144-8-1", lambda t: tam_bagli(8, t),
                                 tb_ileri, False, tb_par),
                                ("evrisimli 2x3x3", lambda t: evrisimli(2, t),
                                 ev_ileri, True, ev_par)):
    for k, tohum in enumerate((TOHUM + 11, TOHUM + 12)):
        P = egit(kur(tohum), ileri, EGT_E, 60, 0.10, tohum + 500, ev)
        print(f"{ad if k == 0 else '':<22}{par if k == 0 else '':>10}{k + 1:>7}"
              f"{dogruluk(P, ileri, EGT_E, ev):>8.4f}"
              f"{dogruluk(P, ileri, SIN_E, ev):>8.4f}")

ag                     parametre  kosum  egitim  sinama
taban cizgisi                  0      -       -  0.5850
tam bagli 144-8-1           1169      1  1.0000  0.5100
                                      2  0.9950  0.5350
evrisimli 2x3x3               23      1  0.7850  0.8000
                                      2  0.8150  0.8150

Üç sayı yan yana duruyor. Taban çizgisi 0,5850. Tam bağlı ağ 1.169 parametreyle eğitim kümesini tamamen ezberliyor — birinci koşumda 1,0000 — ve sınama kümesinde 0,5100 okuyor, yani taban çizgisinin 0,0750 altında. Evrişimli ağ 23 parametreyle sınamada 0,8000 okuyor, taban çizgisini 0,2150 geçiyor.

Tam bağlı ağın başarısızlığı bir eğitim kusuru değildir. İki yüz ızgara 144 boyutlu ikili bir uzayda birbirine hiç benzemez; ağ her birini ayrı ayrı ezberleyecek kadar geniştir ve ezberlemek, hattın nerede olduğunu öğrenmekten kolaydır. Hat başka bir yerde göründüğünde ezberlenen ağırlıkların hiçbiri işe yaramaz.

Üçüncü sayı her iki ağda da yazılıdır. Tam bağlı ağın iki koşumu 0,5100 ile 0,5350, fark 0,0250; evrişimli ağınki 0,8000 ile 0,8150, fark 0,0150. Kapasite, veri ve bütçe sabitken yalnız başlangıç değerlerinin değişmesi ölçülebilir bir fark açıyor. Tek bir koşumun sayısını yazmak bu belirsizliği görünmez kılmak demektir.

Evrişimli ağ elle yazılmış iki çekirdeğin 0,9380’ine de ulaşamıyor. Nedeni kapasite değil, ilk katmandan sonra yapılandır: her çekirdeğin bütün ızgaradaki en büyük değeri alınıp geri kalan 143 konum atılıyor. Bu ağ “hat var mı” sorusunu yanıtlar, “nerede” sorusunu yanıtlamaz.

Özet

• Kapsama ızgarası kurgudur: 12x12 hücre, yüzde 9 etkinlik, etiket bitişik üç hücrelik bir hat; sınamada en sık sınıf 0,5850.
• Aynı 144 çıktıyı üreten tam bağlı katman 20.880, tek bir 3x3 evrişim çekirdeği 10 sayı tutar; oran 2.088 kattır ve kaynağı ağırlık paylaşımıdır.
• Çıktı boyutu adım, dolgu ve çekirdek boyundan hesaplanır; ağırlık sayısı bu üçünden bağımsızdır, yalnız çarpma sayısı değişir (adım 1 dolgu 1’de 1.296, adım 3’te 144).
• Dolgusuz çalışmak kenardaki hatları görmez: uyuşma 0,8900’den 0,9380’e çıkar, fark 0,0480.
• 1.169 parametreli tam bağlı ağ eğitim kümesini ezberleyip sınamada 0,5100 ve 0,5350 okur, taban çizgisinin altında kalır; 23 parametreli evrişimli ağ 0,8000 ve 0,8150 okur.
• İkinci koşumun açtığı fark tam bağlı ağda 0,0250, evrişimli ağda 0,0150’dir.

Sonraki Adım

Evrişimli ağın ilk katmanı 144 konumda bir yanıt üretti, ama ağ yalnız en büyüğünü kullanıp kalan 143 sayıyı attı. Bu, atılabilecek en uç örnektir: konum bilgisinin tamamı gitmiştir. Sonraki ders bunu ayarlanabilir bir adıma çevirir; komşu konumların yanıtları küçük pencerelerde birleştirilir. Ölçülecek üç şey vardır: çıktı boyutunun kaça düştüğü, atılan hücrelerin kaçının geri kurulabildiği ve ızgara bir hücre kaydırıldığında kararın kaç örnekte değiştiği.