Etkinleştirme Fonksiyonları

Önceki ders doğrusal olmayan ayrımın etkinleştirme fonksiyonundan geldiğini ölçtü, ama kullanılan iki işlev hiçbir gerekçeyle seçilmedi. Bir etkinleştirmenin ağa kattığı şey yalnız eğrisi değildir; eğitim sırasında geriye akan eğimi de o işlev belirler. Eğim zincir kuralıyla katman katman çarpılarak gerideki katmanlara ulaşır ve çarpanlardan biri etkinleştirmenin türevidir.

Bu dersin ölçüsü buradadır. Bir işlevin türevi girdinin bir bölgesinde neredeyse sıfıra iniyorsa, o bölgede kalan birim eğim almaz ve öğrenmesi durur. Bunun iki ayrı biçimi vardır ve karıştırılır: türev küçülür ama sıfır olmaz — doygunluk; ya da türev tam olarak sıfırdır — ölü birim. İkisi ayrı ölçülür.

• SA8. Küme, bölme, tohum ve on iki sütun 01’deki gibidir; eğitim kümesi yine 300 satıra küçültülmüştür. Taban çizgisi sınama kümesinde 0,7579.
• SA9. Ağ 01’in ağıdır: 12 girdi, sekiz birimlik bir ara katman, tek çıktı, 113 parametre. Değişen tek şey ara katmanın etkinleştirmesidir.
• SA10. Çıkış katmanı üç kurulumda da sigmoittir, çünkü çıktının bir olasılık olması gerekir. Karşılaştırma yalnız ara katman üzerinden yapılır.
• SA11. Türev, etkinleştirmenin çıktısı cinsinden yazılır. Sigmoit için $a(1-a)$, hiperbolik tanjant için $1-a^2$, doğrultulmuş birim için çıktı pozitifken 1, değilse 0.
• SA12. Bir birim, ara katmandaki türevi tavanının yüzde beşinin altında kalıyorsa o satırda etkin sayılmaz. Eğitim kümesinin 300 satırının hiçbirinde etkin olmayan birim ölüdür.
• SA13. İlk katmana ulaşan eğim, ilk turun ağırlık eğimlerinin ortalama mutlak büyüklüğüdür. Üç kurulum aynı başlangıç değerlerinden başladığı için sayılar karşılaştırılabilir.
• SA14. Öğrenme adımı süpürmesi bir ayar araması değildir; ölü birimin hangi adımda ortaya çıktığını göstermek için yapılır ve seçim yapmaz.

Doygunluk Bir Sayıdır

Doygunluk sözle anlatıldığında bir eğri betimlemesi olarak kalır. Sayıya çevrilince ne kadar sert bir sınır olduğu görünür: aynı işlevin türevi girdinin iki noktasında kaç kat ayrılıyor.

# etkinlestirme.py — MODELDIR. Ayni KURGU abone tablosu, ayni tohum ve ayni bolme;
# egitim kumesi 01'deki gibi 300 satira kucultulmustur.
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):
    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 kume(veri):
    return ([[(x[a] - ORTALAMA[a]) / SAPMA[a] for a in ALAN] for x in veri],
            [float(x["supheli"]) for x in veri])


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


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)


ETKIN = {                                   # (islev, turev — girdisi etkinlestirme ciktisi)
    "sigmoit": (sikistir, lambda a: a * (1.0 - a)),
    "hiperbolik tanjant": (math.tanh, lambda a: 1.0 - a * a),
    "dogrultulmus": (lambda z: z if z > 0.0 else 0.0, lambda a: 1.0 if a > 0.0 else 0.0),
}
Z = (0.0, 1.0, 2.0, 4.0, 6.0, 8.0)
print(f"egitim {len(XE)}, dogrulama {len(XD)}, sinama {len(XS)}, "
      f"taban cizgisi {TABAN:.4f}")
print("\n" + f"{'turev':<20}" + "".join(f"{'z=' + str(int(z)):>10}" for z in Z))
for ad, (f, t) in ETKIN.items():
    print(f"{ad:<20}" + "".join(f"{t(f(z)):>10.4f}" for z in Z))
for ad, (f, t) in ETKIN.items():
    print(f"{ad:<20} z=1'de {t(f(1.0)):.6f}, z=6'da {t(f(6.0)):.6f}, "
          f"oran {t(f(1.0)) / max(t(f(6.0)), 1e-12):.1f}")

egitim 300, dogrulama 252, sinama 252, taban cizgisi 0.7579

turev                      z=0       z=1       z=2       z=4       z=6       z=8
sigmoit                 0.2500    0.1966    0.1050    0.0177    0.0025    0.0003
hiperbolik tanjant      1.0000    0.4200    0.0707    0.0013    0.0000    0.0000
dogrultulmus            0.0000    1.0000    1.0000    1.0000    1.0000    1.0000
sigmoit              z=1'de 0.196612, z=6'da 0.002467, oran 79.7
hiperbolik tanjant   z=1'de 0.419974, z=6'da 0.000025, oran 17088.4
dogrultulmus         z=1'de 1.000000, z=6'da 1.000000, oran 1.0

Sigmoidin türevi hiçbir yerde 0,25’i geçmiyor. Bu tek başına bir sınırdır: on iki sütunlu bir girdiden gelen eğim, ara katmanı geçerken en iyi ihtimalle dörtte birine iner. Girdi 6’ya çıkınca türev 0,0025 olur ve oran 79,7’ye varır. Hiperbolik tanjant tavanda daha cömerttir — türevi 1’den başlar — ama daha hızlı doyar: aynı iki nokta arasındaki oran 17.088. Doğrultulmuş birimin türevi pozitif bölgede sabit 1’dir, negatif bölgede tam olarak 0.

Üç Etkinleştirme, İki Koşum

Tablo tek başına hangisinin daha iyi olduğunu söylemez, çünkü ağın gerçekte hangi girdi bölgesinde çalıştığı ölçülmemiştir. Aynı ağ üç etkinleştirmeyle, aynı başlangıç değerlerinden, ikişer koşumla eğitilir.

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, f):                        # ILERI GECIS, cikis katmani her zaman sigmoit
    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 [f(t) for t in z]
        ara.append(a)
    return ara


def egit(ag, X, Y, adim, tur, ad):          # MODELDIR: tam toplu egim inisi
    f, turev = ETKIN[ad]
    n, ilk = len(X), [0.0]
    for t 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], f)
            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[p] * turev(a[p]) for p in range(len(a))]
        if t == 0:                          # ilk katmana ulasan ortalama egim buyuklugu
            ilk[0] = sum(abs(v) for s in gW[0] for v in s) / (len(gW[0]) * len(gW[0][0]))
        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, ilk[0]


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


def birim_olcum(ag, X, ad):                 # birim basina etkin satir sayisi ve ort. turev
    f, turev = ETKIN[ad]
    W, y = ag[0]
    tavan = 0.25 if ad == "sigmoit" else 1.0
    sayac, toplam = [0] * len(W), 0.0
    for x in X:
        for j in range(len(W)):
            t = turev(f(sum(w * v for w, v in zip(W[j], x)) + y[j]))
            toplam += t
            if t > 0.05 * tavan:
                sayac[j] += 1
    return sayac, toplam / (len(X) * len(W))


SONUC = {}
print(f"{'etkinlestirme':<20} {'kosum':>6} {'dogrulama':>10} {'sinama':>8} "
      f"{'ort_turev':>10} {'ilk_katman_egimi':>17}")
for ad in ETKIN:
    SONUC[ad] = []
    for kosum in (1, 2):
        ag, ilk = egit(ilklendir(TOHUM + kosum, [12, 8, 1]), XE, YE, 0.3, 100, ad)
        sayac, ort = birim_olcum(ag, XE, ad)
        SONUC[ad].append((dogruluk(ag, XD, YD, ad), dogruluk(ag, XS, YS, ad), ort, ilk))
        print(f"{ad:<20} {kosum:>6} {SONUC[ad][-1][0]:>10.4f} {SONUC[ad][-1][1]:>8.4f} "
              f"{ort:>10.4f} {ilk:>17.4f}")
SEC = max(ETKIN, key=lambda a: SONUC[a][0][0])
print(f"\ndogrulamadan secilen etkinlestirme: {SEC}")
print(f"taban cizgisi {TABAN:.4f}, agin sayisi {SONUC[SEC][0][1]:.4f}, "
      f"ikinci kosum {SONUC[SEC][1][1]:.4f}")
print(f"ilk katman egimi: {SEC} {SONUC[SEC][0][3]:.4f}, dogrultulmus "
      f"{SONUC['dogrultulmus'][0][3]:.4f}, oran "
      f"{SONUC['dogrultulmus'][0][3] / SONUC[SEC][0][3]:.2f} kat")

etkinlestirme         kosum  dogrulama   sinama  ort_turev  ilk_katman_egimi
sigmoit                   1     0.8294   0.7937     0.1971            1.0456
sigmoit                   2     0.8333   0.7976     0.2100            1.5007
hiperbolik tanjant        1     0.7976   0.7659     0.5913            3.1693
hiperbolik tanjant        2     0.8016   0.7698     0.6587            4.8762
dogrultulmus              1     0.8214   0.7857     0.5183            4.4498
dogrultulmus              2     0.8056   0.7698     0.5012            5.2971

dogrulamadan secilen etkinlestirme: sigmoit
taban cizgisi 0.7579, agin sayisi 0.7937, ikinci kosum 0.7976
ilk katman egimi: sigmoit 1.0456, dogrultulmus 4.4498, oran 4.26 kat

Eğim ölçüsü tabloyu doğruluyor: ilk katmana ulaşan ortalama eğim büyüklüğü sigmoitle 1,0456, doğrultulmuş birimle 4,4498 — 4,26 kat. Bu fark doğrudan türev tavanından geliyor ve sözle anlatılan doygunluğun ağdaki karşılığıdır.

Ama sınama sütunu beklenenin tersini söylüyor. Doygun işlev en yüksek sayıyı veriyor: 0,7937 ve 0,7976. Nedeni ortalama türev sütununda: sigmoit birimlerinin ortalama türevi 0,1971, tavanı olan 0,2500’ün yüzde 79’u. Ağ doygun bölgede çalışmıyor, çünkü ölçeklenmiş girdilerle ağırlıklı toplam küçük kalıyor. Doygunluk bir işlev özelliği değil, o işlevin hangi bölgede çalıştırıldığına bağlı bir sonuçtur. Bu ölçekte küçük eğim bir engel değil; katman derinleştiğinde ve aynı çarpan üst üste bindiğinde engel olacak.

Üçlü yine yerinde: taban çizgisi 0,7579, ağın sayısı 0,7937, ikinci koşum 0,7976. İki koşum arasındaki fark bir abone; ama üç etkinleştirme arasındaki en büyük fark 0,7937 ile 0,7659, yani yedi abone. Bu derste seçim koşum gürültüsünün üstünde bir fark üretiyor.

Ölü Birim ile Doygun Birim

İki bozulma biçimini ayırmanın yolu öğrenme adımını büyütmektir. Adım büyüdükçe ağırlıklar daha uzağa savrulur ve birimler türevin küçük olduğu bölgeye girer.

print(f"{'etkinlestirme':<20} {'adim':>6} {'sinama':>8} {'olu birim':>10} "
      f"{'ort_turev':>10}  birim basina etkin satir")
for ad in ETKIN:
    for adim in (0.3, 20.0, 30.0):
        ag, _ = egit(ilklendir(TOHUM + 1, [12, 8, 1]), XE, YE, adim, 100, ad)
        sayac, ort = birim_olcum(ag, XE, ad)
        print(f"{ad:<20} {adim:>6} {dogruluk(ag, XS, YS, ad):>8.4f} "
              f"{sum(1 for c in sayac if c == 0):>10} {ort:>10.4f}  {sayac}")

etkinlestirme          adim   sinama  olu birim  ort_turev  birim basina etkin satir
sigmoit                 0.3   0.7937          0     0.1971  [300, 300, 300, 300, 300, 300, 300, 300]
sigmoit                20.0   0.7579          0     0.0536  [176, 127, 118, 119, 132, 169, 141, 127]
sigmoit                30.0   0.6071          0     0.0295  [89, 68, 66, 70, 53, 95, 85, 71]
hiperbolik tanjant      0.3   0.7659          0     0.5913  [296, 299, 291, 291, 283, 289, 288, 282]
hiperbolik tanjant     20.0   0.7381          0     0.0528  [28, 37, 62, 27, 35, 36, 11, 47]
hiperbolik tanjant     30.0   0.6667          0     0.0259  [5, 26, 17, 22, 15, 18, 15, 24]
dogrultulmus            0.3   0.7857          0     0.5183  [151, 185, 143, 142, 154, 134, 132, 203]
dogrultulmus           20.0   0.7579          4     0.0825  [0, 30, 91, 33, 44, 0, 0, 0]
dogrultulmus           30.0   0.7540          8     0.0000  [0, 0, 0, 0, 0, 0, 0, 0]

Ayrım son sütunda duruyor. Sigmoit ve hiperbolik tanjantla hiçbir birim ölmüyor: adım 30’da bile her birim 300 satırın bir bölümünde etkin kalıyor, 53 ile 95 arasında. Ortalama türev 0,1971’den 0,0295’e iniyor — altı kat küçülme — ve sayı 0,6071’e, taban çizgisinin çok altına düşüyor. Ama türev sıfır değil; ağ yavaş da olsa öğrenmeye devam edebilir.

Doğrultulmuş birimde durum başkadır. Adım 20’de sekiz birimin dördü, adım 30’da sekizi de ölüyor ve ortalama türev tam olarak 0,0000 oluyor. Ölü bir birimin geri akan eğimi sıfırla çarpılır; ağırlıkları bir daha hiç güncellenmez. Bu geri dönüşü olmayan bir kayıptır ve tabloda sayıyla görünür: sekiz birimin sekizi öldüğünde ağın çıktısı sabittir ve sınama sayısı 0,7540, yani taban çizgisinin bile altında. Adım 20’de dört birim ölmüş haldeyken sayı tam olarak 0,7579, yani ağ herkese “şüpheli değil” diyor.

Özet

• Doygunluk bir sayıdır: sigmoidin türevi z=1’de 0,1966 iken z=6’da 0,0025, oran 79,7; hiperbolik tanjantta aynı oran 17.088. Doğrultulmuş birimin türevi pozitif bölgede sabit 1’dir.
• Aynı ağda ilk katmana ulaşan ortalama eğim sigmoitle 1,0456, doğrultulmuş birimle 4,4498 — 4,26 kat. Fark doğrudan türev tavanından gelir.
• Üçlü: taban çizgisi 0,7579, ağın sayısı 0,7937 (sigmoit), ikinci koşum 0,7976. Etkinleştirmeler arasındaki en büyük fark yedi abone, iki koşum arasındaki fark bir abone.
• Doygunluk bir işlev özelliği değil, işlevin çalıştırıldığı bölgenin sonucudur: sigmoit birimlerin ortalama türevi 0,1971, yani tavanının yüzde 79’u, çünkü ölçeklenmiş girdilerle toplam küçük kalıyor.
• Ölü birim ile doygun birim ayrı şeylerdir. Adım 30’da sigmoit ve hiperbolik tanjantta hiçbir birim ölmüyor, doğrultulmuş birimde sekizinin sekizi ölüyor ve ortalama türev 0,0000 oluyor; sayı 0,7540 ile taban çizgisinin altına iniyor.

Sonraki Adım

İki derste ağ hep aynı kaldı: on iki girdi, sekiz birim, tek çıktı. Ara katmanın kaç birim taşıyacağı seçilmedi, seçilseydi neyin değişeceği ölçülmedi. Sonraki ders ileri geçişi katman katman açar ve bu seçime iki ayrı sayı bağlar: birim sayısı arttıkça parametre sayısı ve bir tek örnek için yapılan çarpma sayısı nasıl büyüyor, ve ayrılmış küme sayısı bu büyümeye ne kadar karşılık veriyor. Dizey çarpımı elle yazılır, çünkü katmanın maliyeti ancak açık yazıldığında sayılabilir.