Donanım Kullanımı

Önceki ders toplu boyu otuzda sabit tuttu. Bu sayı bir kaynağa bağlıdır: bir güncellemede kaç örneğin ileri ve geri geçişinin aynı anda bellekte durabileceğine. Hızlandırıcı bir donanım sınıfıdır ve bu dersin konusu hiçbir ürünün özellikleri değil, her hızlandırıcıda aynı olan hesaptır: toplu boy büyüdükçe hangi büyüklük ne kadar büyür.

İkinci soru ilkinin gölgesinde durur. Toplu boy bir bellek kararı gibi görünür, ama eğim inişinin attığı adımın büyüklüğünü de değiştirir: bir toplunun eğimi o toplunun ortalamasıdır ve toplu büyüdükçe ortalama sakinleşir. Dersin ölçüsü iki sayıdır: toplu boyun sayı adedini ne kadar büyüttüğü, ve toplu boy tek başına değiştirildiğinde sınama sayısının ne kadar düştüğü.

• EP12. Küme, ağ, taban çizgisi ve geri açıklık 01. dersten devralınır; tur sayısı bu derste 40’ta sabittir ve toplu boy değiştikçe güncelleme sayısı buna göre değişir.
• EP13. Ölçü sayı adedidir, bayt değil. Bir sayının kaç bayt tuttuğu bir tip kararıdır ve M26/K04’ün bellek dersinde ölçüldü: orada aynı sütun gösterimine göre 173.837, 19.251 ve 3.628 bayt tutmuş, genişlik 8 bayttan 1 bayta indirildiğinde bellek 31,4 kat küçülürken toplam 6,9 m³ kaymıştı. O hesap tekrarlanmaz, girdi alınır.
• EP14. Sayılan üç yığın şudur: parametreler, parametrelerin eğimleri, ve topludaki her örneğin etkinleştirmeleri ile onların eğimleri. Etkinleştirmeler geri geçiş için saklanır; saklanmasalar ileri geçiş yeniden koşardı.
• EP15. Eniyileyicinin kendi durumu ayrıca sayılır: momentumlu iniş parametre başına bir sayı daha ister. Bu ders yalın inişle koşar ve durum sıfırdır.
• EP16. Bellek bütçesi bir kurgu sayıdır (100.000 sayı) ve hiçbir ürünün belleği değildir; amacı bütçeden toplu boya giden hesabı göstermektir.
• EP17. Ölçekli adım kuralı toplu boyla doğru orantılıdır: otuzluk toplu için 0,30 olan adım, üç yüzlük toplu için 3,00 olur. Bu bir kural değil bir adaydır ve ölçülür.

Küme, Ağ ve Taban Çizgisi

# ORTAK — KURGUDUR. M27/K01-K04'un abone tablosu ayni tohumla (20260218) uretilir;
# egitim kumesi 756'dan 300 satira kucultulmustur. Ag, ilklendirme ve elle yazilan
# geri yayilim 01. dersten devralinir; gizli birim sayisi h ile degistirilebilir.
import math

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)]
ALAN = ["b_guney", "b_dogu", "b_bati", "b_merkez",
        "hane", "memnuniyet", "donem", "ortalama"]


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


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


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:
        continue
    no = 10001 + i
    r, v = uretec(TOHUM + 7000 + 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(
            b[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 + no)
    z = (0.052 * (ort - 20) + 0.85 * (min(v) == 0.0) + 0.026 * oyn
         + 0.24 * (hane >= 5) - 0.20 * (memnun >= 4) + b[3]
         + 0.9 * (no - 10001) / 1399 + (r() + r() + r() - 1.5) * 1.30)
    x = {"hane": hane, "memnuniyet": memnun, "donem": len(v),
         "ortalama": round(ort, 2), "supheli": int(z > 1.35)}
    for q in BOLGE[1:]:
        x["b_" + q[0]] = int(b[0] == q[0])
    VERI.append(x)

K = karistir(VERI, TOHUM + 90000)
EGT, SIN = K[:300], K[1008:]


def tablo(satirlar, ist=None):
    X = [[float(s[a]) for a in ALAN] for s in satirlar]
    if ist is None:                       # olcek yalniz egitim kumesinden ogrenilir
        ist = []
        for j in range(4, 8):
            m = sum(v[j] for v in X) / len(X)
            ist.append((j, m, math.sqrt(sum((v[j] - m) ** 2 for v in X) / len(X))))
    for v in X:
        for j, m, sd in ist:
            v[j] = (v[j] - m) / sd
    return X, [s["supheli"] for s in satirlar], ist


XE, yE, IST = tablo(EGT)
XS, yS, _ = tablo(SIN, IST)
TABAN = sum(v == 0 for v in yS) / len(yS)

G, H = len(ALAN), 8


def ilklendir(tohum, h=H):               # kazanc olcekli ilklendirme
    r = uretec(tohum)
    return [(r() * 2 - 1) * math.sqrt(2.0 / G) for _ in range(h * G)] + [0.0] * h \
        + [(r() * 2 - 1) * math.sqrt(2.0 / h) for _ in range(h)] + [0.0]


def egim(p, X, y, par, h=H):             # 01. dersin elle yazilan geri yayilimi
    g = [0.0] * len(p)
    for k in par:
        x, hh = X[k], [0.0] * h
        for j in range(h):
            s = p[h * G + j] + sum(p[j * G + i] * x[i] for i in range(G))
            hh[j] = s if s > 0 else 0.0
        s = p[-1] + sum(p[h * G + h + j] * hh[j] for j in range(h))
        d = (1.0 / (1.0 + math.exp(-s)) if s > -30 else 0.0) - y[k]
        g[-1] += d
        for j in range(h):
            g[h * G + h + j] += d * hh[j]
            if hh[j] > 0:
                g[h * G + j] += d * p[h * G + h + j]
                for i in range(G):
                    g[j * G + i] += d * p[h * G + h + j] * x[i]
    return [v / len(par) for v in g]


def egit(X, y, tohum, toplu=30, adim=0.30, tur=40, h=H):
    p = ilklendir(tohum, h)
    for t in range(tur):
        d = karistir(range(len(X)), TOHUM + 700 + t)
        for b in range(0, len(d) - toplu + 1, toplu):
            p = [a - adim * v for a, v in zip(p, egim(p, X, y, d[b:b + toplu], h))]
    return p


def dogruluk(p, X, y, h=H):
    n = 0
    for k in range(len(X)):
        x = X[k]
        o = p[-1] + sum(p[h * G + h + j] * max(0.0, p[h * G + j]
                        + sum(p[j * G + i] * x[i] for i in range(G)))
                        for j in range(h))
        n += (o >= 0.0) == (y[k] == 1)
    return n / len(X)


print(f"kurgu: egitim {len(XE)} satir (756'dan kucultuldu), sinama {len(XS)}, "
      f"oznitelik {G}, gizli birim {H}, parametre {len(ilklendir(TOHUM))}")
print(f"taban cizgisi (en sik sinifi soylemek, sinamada) {TABAN:.4f}")

kurgu: egitim 300 satir (756'dan kucultuldu), sinama 252, oznitelik 8, gizli birim 8, parametre 81
taban cizgisi (en sik sinifi soylemek, sinamada) 0.7579

Bir Güncellemede Kaç Sayı Tutulur

Parametre sayısı toplu boydan bağımsızdır; etkinleştirme sayısı toplu boyla doğru orantılıdır. İki büyüklüğün oranı ağın biçimine bağlıdır ve tablo bunu üç ağda okur.

# Bellekte tutulan SAYI ADEDI. Bir guncelleme icin uc yigin tutulur: parametreler,
# onlarin egimleri, ve topludaki her ornegin etkinlestirmeleri (ileri gecisin ara
# degerleri geri gecis icin saklanir) ile o etkinlestirmelerin egimleri.
def adet(g, h, katman, toplu, durum=0):
    par = g * h + h + (katman - 1) * (h * h + h) + h + 1
    return par, par * (1 + durum), 2 * toplu * (g + katman * h + 1)


print(f"{'katman':>7} {'gizli':>6} {'toplu':>6} {'parametre':>10} {'egim':>7} "
      f"{'etkinlestirme':>14} {'toplam':>9} {'etkin pay':>10}")
for katman, h in ((1, 8), (1, 64), (4, 64)):
    for toplu in (1, 30, 300):
        p, e, a = adet(G, h, katman, toplu)
        print(f"{katman:>7} {h:>6} {toplu:>6} {p:>10} {e:>7} {a:>14} {p + e + a:>9} "
              f"{a / (p + e + a):>10.4f}")

p, e, a = adet(G, H, 1, 30)
print(f"\nbu dersin agi (1 katman, {H} birim, toplu 30): {p + e + a} sayi; "
      f"toplu 300'de {sum(adet(G, H, 1, 300)):,}")
print(f"momentumlu inis eniyileyici durumu icin parametre basina bir sayi daha "
      f"ister: {sum(adet(G, H, 1, 30, 1))} sayi")
BUTCE = 100000
print(f"\nbutce {BUTCE:,} sayi olsaydi en buyuk toplu boy:")
for katman, h in ((1, 8), (1, 64), (4, 64)):
    par = adet(G, h, katman, 1)[0]
    print(f"  {katman} katman, {h:>2} birim: {(BUTCE - 2 * par) // (2 * (G + katman * h + 1)):>6,}")

 katman  gizli  toplu  parametre    egim  etkinlestirme    toplam  etkin pay
      1      8      1         81      81             34       196     0.1735
      1      8     30         81      81           1020      1182     0.8629
      1      8    300         81      81          10200     10362     0.9844
      1     64      1        641     641            146      1428     0.1022
      1     64     30        641     641           4380      5662     0.7736
      1     64    300        641     641          43800     45082     0.9716
      4     64      1      13121   13121            530     26772     0.0198
      4     64     30      13121   13121          15900     42142     0.3773
      4     64    300      13121   13121         159000    185242     0.8583

bu dersin agi (1 katman, 8 birim, toplu 30): 1182 sayi; toplu 300'de 10,362
momentumlu inis eniyileyici durumu icin parametre basina bir sayi daha ister: 1263 sayi

butce 100,000 sayi olsaydi en buyuk toplu boy:
  1 katman,  8 birim:  2,936
  1 katman, 64 birim:    676
  4 katman, 64 birim:    139

Üç satır üçlüsü üç ayrı düzen gösteriyor. Bir katmanlı sekiz birimli ağda toplu 1’de etkinleştirme payı 0,1735; toplu 30’da 0,8629’a, toplu 300’de 0,9844’e çıkıyor. Bu ağ o kadar küçüktür ki belleğin neredeyse tamamını veri kaplar. Dört katmanlı altmış dört birimli ağda tablo tersine dönüyor: toplu 1’de pay 0,0198, yani bellek parametrelerin ve eğimlerin; ama toplu 300’e çıkıldığında aynı ağda pay 0,8583 oluyor ve toplam 26.772’den 185.242’ye, altı katın üstünde büyüyor. Parametre sayısı bu iki satırda hiç değişmedi.

Hesabın kullanışlı yönü tersten okunduğunda çıkıyor. Bellek bütçesi verildiğinde en büyük toplu boy çözülebilir: yüz bin sayılık kurgu bütçede küçük ağ 2.936, geniş tek katmanlı ağ 676, dört katmanlı ağ 139 örnek alabiliyor. Aynı bütçe, aynı donanım, yirmi kat fark. Toplu boyu bir alışkanlık olarak değil bu bölmenin sonucu olarak seçmek gerekir; ve seçilen sayı bir sonraki bölümün gösterdiği gibi tek başına gelmez.

Toplu Boy ile Öğrenme Adımı Birlikte Değişir

# Toplu boy ile ogrenme adimi BIRLIKTE degisir. Tur sayisi 40'ta sabit; toplu boy
# buyudukce guncelleme sayisi duser. Olcekli adim toplu boyla dogru orantilidir.
print(f"{'toplu':>6} {'guncelleme':>11} {'sabit adim 0.30':>25} {'olcekli adim':>25}")
SABIT, OLCEK = [], []
for toplu in (10, 30, 100, 300):
    a = [dogruluk(egit(XE, yE, TOHUM + k, toplu, 0.30), XS, yS) for k in (1, 2)]
    o = 0.30 * toplu / 30
    b = [dogruluk(egit(XE, yE, TOHUM + k, toplu, o), XS, yS) for k in (1, 2)]
    SABIT += a
    OLCEK += b
    print(f"{toplu:>6} {40 * (len(XE) // toplu):>11} {a[0]:>13.4f} {a[1]:>6.4f}"
          f"   {'adim ' + format(o, '.2f'):>12} {b[0]:>6.4f} {b[1]:>6.4f}")
print(f"sabit adimla dort toplu boyun yayilimi  {max(SABIT) - min(SABIT):.4f} "
      f"({round((max(SABIT) - min(SABIT)) * len(XS))} abone)")
print(f"olcekli adimla ayni yayilim             {max(OLCEK) - min(OLCEK):.4f} "
      f"({round((max(OLCEK) - min(OLCEK)) * len(XS))} abone)")
print(f"taban cizgisi {TABAN:.4f}; sabit adimda en dusuk {min(SABIT):.4f} "
      f"({min(SABIT) - TABAN:+.4f}), olcekli adimda en dusuk {min(OLCEK):.4f} "
      f"({min(OLCEK) - TABAN:+.4f})")

 toplu  guncelleme           sabit adim 0.30              olcekli adim
    10        1200        0.7619 0.7857      adim 0.10 0.8056 0.7937
    30         400        0.8095 0.7937      adim 0.30 0.8095 0.7937
   100         120        0.7897 0.8056      adim 1.00 0.8016 0.8016
   300          40        0.7619 0.7738      adim 3.00 0.8056 0.7937
sabit adimla dort toplu boyun yayilimi  0.0476 (12 abone)
olcekli adimla ayni yayilim             0.0159 (4 abone)
taban cizgisi 0.7579; sabit adimda en dusuk 0.7619 (+0.0040), olcekli adimda en dusuk 0.7937 (+0.0357)

Sol sütun toplu boyun tek başına değiştirilmesinin bedelini gösteriyor. Adım 0,30’da bırakıldığında dört toplu boyun açıklıkı 0,0476, on iki abone: koşum değişkenliğinin (dört abone) üç katı. İki uçta iki ayrı sebep var. Toplu 300’de yalnız kırk güncelleme yapılıyor ve ağ eğitimi bitmeden duruyor; sonuç 0,7619, tabanın yalnız 0,0040 üstünde, yani bir abone. Toplu 10’da güncelleme sayısı 1.200’e çıkıyor ama her eğim yalnız on örneğin ortalaması olduğu için gürültülü; 0,30’luk adım o gürültüyle birlikte fazla büyük kalıyor ve sonuç yine 0,7619’a düşüyor.

Sağ sütun adımı toplu boyla ölçekliyor: 0,10, 0,30, 1,00 ve 3,00. Dört toplu boyun açıklıkı 0,0159‘a iniyor, dört aboneye — yani aynı kurulumun iki koşumu arasındaki farkla aynı büyüklüğe. En düşük sayı 0,7619’dan 0,7937’ye çıkıyor ve tabanın üstündeki fark 0,0040’tan 0,0357’ye. Toplu boy tek başına bir ayar değişkeni değildir: değiştirildiğinde öğrenme adımı da değişmelidir, yoksa ölçülen şey bellek kararının kendisi değil, o kararın yanında unutulmuş adımdır.

Özet

• Bir güncellemede tutulan sayı üç yığındır: parametreler, eğimleri ve topludaki örneklerin etkinleştirmeleriyle onların eğimleri; ilk ikisi toplu boydan bağımsız, üçüncüsü doğru orantılı.
• Bir katmanlı sekiz birimli ağ toplu 30’da 1.182 sayı tutuyor ve bunun 0,8629’u etkinleştirme; dört katmanlı altmış dört birimli ağda pay toplu 1’de 0,0198, toplu 300’de 0,8583.
• Aynı ağda toplu 1’den 300’e çıkmak toplamı 26.772’den 185.242’ye taşıyor; parametre sayısı hiç değişmiyor.
• Yüz bin sayılık kurgu bütçede en büyük toplu boy üç ağ için 2.936, 676 ve 139; aynı bütçe yirmi kat fark üretiyor.
• Tur sayısı sabitken adım 0,30’da bırakılırsa dört toplu boyun açıklıkı 0,0476 (on iki abone) ve en düşüğü 0,7619 ile tabanın bir abone üstünde kalıyor; adım toplu boyla ölçeklendiğinde açıklık 0,0159’a, en düşük sayı 0,7937’ye geliyor.

Sonraki Adım

Üç derste sabitlenen kalem sayısı hızla arttı: tohum, örnek sırası, toplu boy, öğrenme adımı, tur sayısı, artırma ölçeği, ölçekleme istatistiklerinin hangi kümeden okunduğu. Bunların hiçbiri modelin kendisi değildir ve hepsi sonucu oynatır; bu derste tek bir kalemin — adımın — yerinde bırakılması sayıyı on iki abone düşürdü. Bir eğitimin ikinci kez aynı sayıyı vermesi için kaç kalemin sabitlenmesi gerektiği ise hiç sayılmadı. Sonraki ders deney takibini ele alır: sabitlenecek kalemler önceki kursların listelerinin üstüne sayılır ve biri serbest bırakıldığında sonucun ne kadar oynadığı basılır.