Algılayıcı ve Çok Katmanlı Ağ

Yirmi bir derste — on biri etiketsiz — her yöntem özniteliklerin verildiği varsayımıyla çalıştı. Ölçekleme, kodlama, üretme ve azaltma hep elle karar verildi ve her kararın bedeli ayrı ayrı ölçüldü. Bu kararları da verinin kendisinden öğrenen bir yordamın neyi kazandırdığı, ve neyi görünmez kıldığı, hiç sorulmadı.

Sinir ağı bu soruya verilen bir cevap iddiasıdır: ara temsili elle tasarlamak yerine ara katmanların ağırlıklarını da eğitimle belirlemek. Bu ders o iddianın en küçük halini kurar ve kursun üç sayısını yerleştirir: taban çizgisi, ağın sayısı, aynı ağın yalnız başlangıç değerleri değişen ikinci koşumu. Üçüncüsü kursun imzasıdır, çünkü bir ağın sayısı kapasitesinden değil eğitiminden gelebilir. Bir şey daha baştan duyurulur: bu kurgu tablo verisinde ağın karar ağacını ya da doğrusal modeli geçmesi beklenmiyor, ve bu saklanmayacak.

• SA1. Küme, bölme ve tohum M27/K01–K04’ten aynen sürer: kurgu abone tablosu, 756/252/252, tohum 20260218. Hedef şüpheli etiketidir ve taban çizgisi en sık sınıfı söylemektir.
• SA2. Öznitelik kümesi M27/K02’nin bıraktığı on iki sütundur ve kurs boyunca sabittir. Ağ bu sütunları hazır alır; ölçekleme, kodlama ve türetme kararları hâlâ elle verilmiştir.
• SA3. Sütunlar eğitim kümesinden öğrenilen ortalama ve değişkenlikle ölçeklenir. M27/K02 bu adımın eğim temelli bir modele +0,0437 kattığını ölçmüştü; burada varsayılır.
• SA4. Eğitim kümesi bu kursta 300 satıra küçültülür. Gerekçe koşum süresidir: her ders aynı ağı en az iki kez eğitir. Küçültmenin bedeli bu derste ölçülür.
• SA5. Çözüm eğim inişidir; yordamı M27/K03 dogrusal-modeller’de kuruldu ve burada tekrarlanmaz. Eğimin katmanlara nasıl dağıtıldığı 05’in konusudur.
• SA6. Ağırlıklar kazanç ölçekli ilklendirme ile başlatılır: başlangıç aralığı girdi sayısının kareköküyle ölçeklenir. Yanmalar sıfırdan başlar.
• SA7. Ölçü doğruluktur, sınama kümesi 252 abonedir ve bir abone 0,0040 eder. Denenen aday sayısı 4’tür, seçim doğrulama kümesinden yapılır.

Ağırlık, Yanma ve Birim

Bir birim üç parçadan kuruludur: girdilerin her birine bir ağırlık düşer, ağırlıklı toplama bir sabit eklenir, sonuç bir etkinleştirme fonksiyonundan geçirilir. Eklenen sabite bu kursta yanma denir. Ayrım gereklidir: M27/K01’in yanlılık–değişkenlik dengesindeki yanlılık bir hata bileşenidir, buradaki yanma ise öğrenilen bir parametredir ve birimin eşiğini kaydırır.

Yan yana duran birimler bir katman oluşturur. Bu derste iki mimari karşılaştırılır: girdiyi doğrudan çıktıya bağlayan tek katmanlı ağ ve arada sekiz birimlik bir katman taşıyan iki katmanlı ağ.

# sinir_agi.py — MODELDIR. Ayni KURGU abone tablosu, ayni tohum ve ayni bolme;
# hedef kacak ya da ariza suphesi etiketidir.
import math
import statistics

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):                              # kendi yazilan uretec, kitaplik yok
    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 = {"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)}
    x["kisi_basi"] = round(x["ort_tuketim"] / x["hane"], 3)
    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)
EGT, DOG, SIN = K[:756], K[756:1008], K[1008:]
ALAN = ["ort_tuketim", "oynaklik", "hane", "memnuniyet", "donem", "sifir_okuma",
        "kisi_basi", "b_kuzey", "b_guney", "b_dogu", "b_bati", "b_merkez"]
ORTALAMA = {a: statistics.fmean(x[a] for x in EGT) for a in ALAN}
SAPMA = {a: max(1e-9, statistics.pstdev([x[a] for x in EGT])) for a in ALAN}
TABAN = sum(x["supheli"] == 0 for x in SIN) / len(SIN)


def olcekli(x):                             # OGRENME egitimden, UYGULAMA her kumeye
    return [(x[a] - ORTALAMA[a]) / SAPMA[a] for a in ALAN]


def kume(veri):
    return [olcekli(x) for x in veri], [float(x["supheli"]) for x in veri]


XT, YT = kume(EGT)                          # tam egitim kumesi, 756 satir
XE, YE = kume(EGT[:300])                    # KUCULTULMUS egitim kumesi, 300 satir
XD, YD = kume(DOG)
XS, YS = kume(SIN)

print(f"egitim {len(XT)}, kucultulmus egitim {len(XE)}, dogrulama {len(XD)}, "
      f"sinama {len(XS)}, sutun {len(ALAN)}")
print(f"supheli orani tam egitimde {sum(YT) / len(YT):.4f}, "
      f"kucultulmuste {sum(YE) / len(YE):.4f}, sinamada {sum(YS) / len(YS):.4f}")
print(f"taban cizgisi (en sik sinif) sinamada {TABAN:.4f}")

egitim 756, kucultulmus egitim 300, dogrulama 252, sinama 252, sutun 12
supheli orani tam egitimde 0.2222, kucultulmuste 0.2200, sinamada 0.2421
taban cizgisi (en sik sinif) sinamada 0.7579

Karşılaştırma çizgisi M27/K03’ten gelir ve tam 756 satırla ölçülmüştür: eğim temelli doğrusal model ve doğrulamadan ayarlanmış karar ağacı sınama kümesinde 0,8016 veriyor, ayarsız karar ağacı 0,7857. Ağın geçmesi gereken şey taban çizgisi değil, bu sayıdır.

Tek Katmanlı Ağ Yeni Bir Model Değildir

Gizli katmanı olmayan bir ağ on iki ağırlık ile bir yanma taşır, ağırlıklı toplamı S biçimli bir işleve verir ve bir olasılık üretir. Bu tarif M27/K03’ün lojistik bağlanımınınkiyle kelimesi kelimesine aynıdır ve aynılık sınanabilir: ağırlıklar sıfırdan başlatılıp aynı öğrenme adımı ve tur sayısıyla eğitilirse ağ o dersin tablosunu üretmelidir.

def sikistir(z):                            # S bicimli islev, tasma korumali
    if z >= 0:
        return 1.0 / (1.0 + math.exp(-z)) if z < 700 else 1.0
    e = math.exp(z) if z > -700 else 0.0
    return e / (1.0 + e)


def ilklendir(tohum, kat):                  # kazanc olcekli ilklendirme, yanma sifir
    r, ag = uretec(tohum), []
    for a, b in zip(kat, kat[1:]):
        o = math.sqrt(2.0 / a)
        ag.append(([[(r() * 2 - 1) * o for _ in range(a)] for _ in range(b)], [0.0] * b))
    return ag


def ileri(ag, x, dogrusal=False):           # ILERI GECIS: katman katman
    a, ara = x, [x]
    for k, (W, y) in enumerate(ag):
        z = [sum(w * v for w, v in zip(s, a)) + b for s, b in zip(W, y)]
        a = [sikistir(z[0])] if k == len(ag) - 1 else (
            z[:] if dogrusal else [t if t > 0 else 0.0 for t in z])
        ara.append(a)
    return ara


def egit(ag, X, Y, adim, tur, dogrusal=False):   # MODELDIR: tam toplu egim inisi
    n = len(X)
    for _ in range(tur):
        gW = [[[0.0] * len(W[0]) for _ in W] for W, _ in ag]
        gy = [[0.0] * len(y) for _, y in ag]
        for i in range(n):
            ara = ileri(ag, X[i], dogrusal)
            d = [ara[-1][0] - Y[i]]
            for k in range(len(ag) - 1, -1, -1):
                W, a = ag[k][0], ara[k]
                for j, dj in enumerate(d):
                    if dj:
                        s = gW[k][j]
                        for p in range(len(a)):
                            s[p] += dj * a[p]
                        gy[k][j] += dj
                if k:
                    onceki = [0.0] * len(a)
                    for j, dj in enumerate(d):
                        if dj:
                            s = W[j]
                            for p in range(len(a)):
                                onceki[p] += dj * s[p]
                    d = onceki if dogrusal else [onceki[p] if a[p] > 0 else 0.0
                                                 for p in range(len(a))]
        for k, (W, y) in enumerate(ag):
            for j in range(len(W)):
                s, g = W[j], gW[k][j]
                for p in range(len(s)):
                    s[p] -= adim * g[p] / n
                y[j] -= adim * gy[k][j] / n
    return ag


def dogruluk(ag, X, Y, dogrusal=False):
    return sum((ileri(ag, x, dogrusal)[-1][0] > 0.5) == (y > 0.5)
               for x, y in zip(X, Y)) / len(X)


def parametre(kat):
    return sum(a * b + b for a, b in zip(kat, kat[1:]))


print(f"tek katmanli agin parametre sayisi {parametre([12, 1])}, "
      f"iki katmanli (8 birim) {parametre([12, 8, 1])}")
print(f"{'ogrenme adimi':>14} {'tur':>5} {'egitimde':>9} {'dogrulama':>10} {'sinama':>8}")
for adim, tur in ((0.1, 100), (0.1, 300), (0.1, 600)):
    ag = egit([([[0.0] * 12], [0.0])], XT, YT, adim, tur)   # sifirdan ilklendirme
    print(f"{adim:>14} {tur:>5} {dogruluk(ag, XT, YT):>9.4f} "
          f"{dogruluk(ag, XD, YD):>10.4f} {dogruluk(ag, XS, YS):>8.4f}")

tek katmanli agin parametre sayisi 13, iki katmanli (8 birim) 113
 ogrenme adimi   tur  egitimde  dogrulama   sinama
           0.1   100    0.8175     0.8056   0.8016
           0.1   300    0.8201     0.8373   0.7937
           0.1   600    0.8188     0.8373   0.8016

Üç satırın dokuz sayısı da M27/K03’ün lojistik bağlanım tablosunun ilk üç satırıyla son basamağına kadar aynı. Tek katmanlı ağ yeni bir model ailesi değil, bilinen bir modelin başka bir sözlükle yazılmış halidir. “Sinir ağı” adının kattığı hiçbir şey bu satırlarda yok.

Katmanı Doğrusal Olmayan Yapan Şey

Aradaki katman 113 parametre getiriyor, tek katmanlı ağın 13’üne karşı. Ama kapasite yalnız parametre sayısı değildir. Ara katmanın etkinleştirmesi kimlik işlevi olarak bırakılırsa — yani ağırlıklı toplam olduğu gibi geçirilirse — iki dizey çarpımının bileşimi yine tek bir dizey çarpımıdır. Ağın temsil edebildiği işlevler kümesi değişmez; aynı işlev daha çok parametreyle yazılmış olur.

Ölçü bunu gösterir: üç mimari, aynı ayar, iki koşum. Ara katmanın etkinleştirmesi bir kez kimlik işlevi, bir kez doğrultulmuş doğrusal birim — sıfırın altını sıfıra kesen işlev.

MIMARI = (("tek katmanli", [12, 1], False),
          ("iki katman dogrusal", [12, 8, 1], True),
          ("iki katman dogrultulmus", [12, 8, 1], False))
print(f"{'mimari':<24} {'parametre':>9} {'kosum':>6} {'egitimde':>9} "
      f"{'dogrulama':>10} {'sinama':>8}")
BANT = {}
for ad, kat, dg in MIMARI:
    BANT[ad] = []
    for kosum in (1, 2):
        ag = egit(ilklendir(TOHUM + kosum, kat), XE, YE, 0.3, 100, dg)
        s = dogruluk(ag, XS, YS, dg)
        BANT[ad].append(s)
        print(f"{ad:<24} {parametre(kat):>9} {kosum:>6} "
              f"{dogruluk(ag, XE, YE, dg):>9.4f} {dogruluk(ag, XD, YD, dg):>10.4f} {s:>8.4f}")
print()
for ad, v in BANT.items():
    print(f"{ad:<24} sinama bandi {min(v):.4f}-{max(v):.4f}")

mimari                   parametre  kosum  egitimde  dogrulama   sinama
tek katmanli                    13      1    0.8433     0.7976   0.7817
tek katmanli                    13      2    0.8300     0.8016   0.7698
iki katman dogrusal            113      1    0.8233     0.8056   0.7698
iki katman dogrusal            113      2    0.8267     0.8016   0.7738
iki katman dogrultulmus        113      1    0.8400     0.8214   0.7857
iki katman dogrultulmus        113      2    0.8367     0.8056   0.7698

tek katmanli             sinama bandi 0.7698-0.7817
iki katman dogrusal      sinama bandi 0.7698-0.7738
iki katman dogrultulmus  sinama bandi 0.7698-0.7857

Doğrusal etkinleştirmeli ağ 113 parametresine karşın tek katmanlının bandının içinde kalıyor: 0,7698–0,7738’e karşı 0,7698–0,7817. Sekiz kat parametre ayrı bir sayı üretmeye yetmiyor. Doğrusal olmayan ayrım katman sayısından değil etkinleştirme fonksiyonundan geliyor; 0,7857 ötekilerin üstüne çıkan tek sayı ve doğrultulmuş birimli ağa ait.

Kursun İmzası: İkinci Koşum

Üst uç 0,7857 tek başına raporlanabilir bir sayıdır ve raporlandığında yanıltır. Aynı ağ, aynı veri, aynı ayar — yalnız başlangıç değerleri değişerek — beş kez eğitilir.

ADAY = []
print(f"{'adim':>5} {'tur':>5} {'dogrulama':>10} {'sinama':>8}")
for adim in (0.3, 0.5):
    for tur in (100, 200):
        ag = egit(ilklendir(TOHUM + 1, [12, 8, 1]), XE, YE, adim, tur)
        ADAY.append((adim, tur, dogruluk(ag, XD, YD), dogruluk(ag, XS, YS)))
        print(f"{adim:>5} {tur:>5} {ADAY[-1][2]:>10.4f} {ADAY[-1][3]:>8.4f}")
SEC = max(ADAY, key=lambda t: t[2])
print(f"denenen aday {len(ADAY)}, secilen (adim {SEC[0]}, tur {SEC[1]})\n")

KOSUM = {}
print(f"{'kosum':>6} {'tek katmanli':>14} {'iki katmanli':>14}")
for kosum in range(1, 6):
    satir = []
    for kat in ([12, 1], [12, 8, 1]):
        ag = egit(ilklendir(TOHUM + kosum, kat), XE, YE, SEC[0], SEC[1])
        satir.append(dogruluk(ag, XS, YS))
    KOSUM[kosum] = satir
    print(f"{kosum:>6} {satir[0]:>14.4f} {satir[1]:>14.4f}")

tek, iki = [KOSUM[k][0] for k in KOSUM], [KOSUM[k][1] for k in KOSUM]
print(f"\ntaban cizgisi {TABAN:.4f}, agin sayisi {iki[0]:.4f}, "
      f"ikinci kosum {iki[1]:.4f}, fark {round(abs(iki[0] - iki[1]) * len(XS))} abone")
for ad, v in (("tek katmanli", tek), ("iki katmanli", iki)):
    print(f"{ad:<13} bant {min(v):.4f}-{max(v):.4f}, kosum degiskenligi "
          f"{max(v) - min(v):.4f} = {round((max(v) - min(v)) * len(XS))} abone")
print(f"kapasitenin kattigi {max(iki) - max(tek):.4f} "
      f"= {round((max(iki) - max(tek)) * len(XS))} abone; kucultmenin bedeli "
      f"(756 satirda 0.8016) {0.8016 - max(tek):.4f} "
      f"= {round((0.8016 - max(tek)) * len(XS))} abone")

 adim   tur  dogrulama   sinama
  0.3   100     0.8214   0.7857
  0.3   200     0.8135   0.7817
  0.5   100     0.8175   0.7857
  0.5   200     0.7937   0.7738
denenen aday 4, secilen (adim 0.3, tur 100)

 kosum   tek katmanli   iki katmanli
     1         0.7817         0.7857
     2         0.7698         0.7698
     3         0.7738         0.7738
     4         0.7698         0.7817
     5         0.7698         0.7659

taban cizgisi 0.7579, agin sayisi 0.7857, ikinci kosum 0.7698, fark 4 abone
tek katmanli  bant 0.7698-0.7817, kosum degiskenligi 0.0119 = 3 abone
iki katmanli  bant 0.7659-0.7857, kosum degiskenligi 0.0198 = 5 abone
kapasitenin kattigi 0.0040 = 1 abone; kucultmenin bedeli (756 satirda 0.8016) 0.0199 = 5 abone

Son iki satır kursun kuralını kuruyor. Kapasitenin kattığı fark bir abone, aynı kapasitenin koşumdan koşuma oynaması beş abone. Ağın 0,7857’si kapasiteden değil o koşumun başlangıç değerlerinden geliyor; beşinci koşum 0,7659 veriyor ve o sayı taban çizgisinin yalnız iki abone üstünde. Tek katmanlı ağın bandı daha dar, üç abone, çünkü çözdüğü problemin tek bir en iyi noktası vardır; ara katman eklendiğinde o güvence kayboluyor.

İkinci iddia da tablodan okunuyor. Ağın en iyi koşumu 0,7857 ile ayarsız karar ağacına eşit ve M27/K03’ün iki ailesinin 0,8016’sının dört abone altında. Farkın bir bölümü eğitim kümesinin küçültülmesinden geliyor: aynı tek katmanlı ağ 756 satırla 0,8016, 300 satırla 0,7817 veriyor. Kalanı verinin kendisiyle ilgilidir — on iki sütunlu bir abone tablosunda öğrenilecek ara temsil azdır.

Özet

• Bir birim ağırlık, yanma ve etkinleştirme fonksiyonundan kuruludur; yanma bir katman parametresidir ve M27/K01’in hata bileşeni olan yanlılıktan ayrıdır.
• Gizli katmanı olmayan ağ, sıfırdan ilklendirildiğinde M27/K03’ün doğrusal modelinin dokuz sayısını da son basamağına kadar veriyor: 0,8016, 0,7937 ve 0,8016.
• Ara katmanın etkinleştirmesi kimlik işlevi bırakılırsa 113 parametreli ağ 13 parametrelinin bandından çıkamıyor; doğrusal olmayan ayrım katman sayısından değil etkinleştirmeden gelir.
• Üçlü: taban çizgisi 0,7579, ağın sayısı 0,7857, ikinci koşum 0,7698. Beş koşumun bandı 0,7659–0,7857; koşum değişkenliği beş abone, kapasitenin kattığı bir abone.
• Ağ 0,7857’de kalıyor: ayarsız karar ağacına eşit, M27/K03’ün iki ailesinin 0,8016’sının dört abone altında; farkın beş abonesi eğitim kümesinin 300 satıra küçültülmesinden geliyor.

Sonraki Adım

Doğrusal olmayan ayrımın etkinleştirmeden geldiği ölçüldü, ama kullanılan iki işlev — sıfırın altını kesen doğrultulmuş doğrusal birim ve çıktıdaki S biçimli sıkıştırma — hiçbir gerekçeyle seçilmedi. Sonraki ders o seçimi bir tercih olarak değil bir sayı olarak ele alır: sıkıştıran bir işlev uçlarda düzleşir ve eğimi neredeyse sıfıra iner, kesen bir işlev ise girdisi sıfırın altında kalan birimi tümüyle susturur. Sekiz birimin kaçı hiçbir örnekte etkinleşmiyor ve doygunluk eğimi kaç kat küçültüyor — üç etkinleştirme yan yana, her biri iki koşumla.