Veri Yükleme Hattı

Önceki ders eğimi iki yoldan hesapladı ve ikisinin makine duyarlığında aynı sayıyı verdiğini gösterdi. O dersin eğitim döngüsünde bir satır sorgusuz geçti: eğitim kümesi her turda karıştırıldı ve otuzarlık topluya bölündü. Bu satır ağın ne gördüğünü değil hangi sırayla gördüğünü belirler.

Veri yükleme hattı üç karardan oluşur: hangi örnekler, hangi sırayla, kaç tanesi bir arada. Üçüncüsü toplu boyudur ve sonraki derse bırakılır. Bu ders ilk ikisini ölçer ve bir dördüncüyü ekler: veri artırma (augmentation). Ölçü iki sayıdır: artırmanın kattığı fark ve artırmanın sızıntı ürettiği durumdaki şişme.

• EP7. Küme, ağ, taban çizgisi ve elle yazılan geri yayılım önceki dersten devralınır: kurgu abone tablosu, 300 satırlık eğitim kümesi, 8-8-1 ağ, 81 parametre, sınamada taban 0,7579.
• EP8. Karşılaştırmaların koşabilmesi için güncelleme sayısı 400’de sabit tutulur. Artırılmış küme iki kat büyük olduğu için tur sayısı kırktan yirmiye iner; ağ her iki kurulumda da aynı sayıda eğim adımı atar.
• EP9. Artırma burada tablo verisine gürültü eklemektir ve bir modeldir: sürekli dört sütuna standart sapma birimiyle ölçülen gürültü eklenmiş kopya satırlar üretilir, etiket kopyalanır ve değiştirilmez. Alana özgü artırma yordamları M27/K06’ya bırakılır.
• EP10. Sızıntı kurulumunda sınama kümesi her iki durumda da aynı 252 orijinal satırdır; değişen yalnız eğitim kümesine hangi satırların ikizinin girdiğidir. Sızıntı M27/K02’de ölçüldü, yordamı tekrarlanmaz.
• EP11. Koşum değişkenliği bir gürültü değil, ölçülen bir büyüklüktür: her karşılaştırma en az iki koşumla basılır ve kattığı fark bu aralıkla birlikte okunur.

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 ve elle yazilan geri yayilim
# onceki dersten devralinir: 8-8-1, 81 parametre, 400 guncelleme, adim 0.30.
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):                    # 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):                  # onceki 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]


ADIM, TOPLU = 0.30, 30


def egit(X, y, tohum, sira, guncelleme=400):
    p, t = ilklendir(tohum), 0
    while t * (len(X) // TOPLU) < guncelleme:
        d = sira(t, len(X))
        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]))]
        t += 1
    return p


def dogruluk(p, X, y):
    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}, 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, parametre 81
taban cizgisi (en sik sinifi soylemek, sinamada) 0.7579

Toplu Üretim Sırası

Dört sıra kararı vardır ve dördü de savunulabilir. Sırasız: satırlar dosyadaki sırayla verilir, her tur aynı toplular kurulur. Bir kez: küme başlangıçta bir kez karıştırılır ve o sıra kırk tur korunur. Her tur: küme her turda yeniden karıştırılır ve toplular her turda başka satırlardan kurulur; bu sonuncusu iki ayrı tohumla denenir.

# Toplu uretim SIRASI bir karardir: ayni veri, ayni ag, ayni 400 guncelleme.
# Dort sira, her biri iki ilklendirmeyle.
DIZI = {"sirasiz": lambda t, n: list(range(n)),
        "bir kez": lambda t, n: karistir(range(n), TOHUM + 700),
        "her tur A": lambda t, n: karistir(range(n), TOHUM + 700 + t),
        "her tur B": lambda t, n: karistir(range(n), TOHUM + 800 + t)}
S = {}
print(f"{'toplu sirasi':<13} {'kosum 1':>8} {'kosum 2':>8} {'fark':>8}")
for ad, s in DIZI.items():
    S[ad] = [dogruluk(egit(XE, yE, TOHUM + k, s), XS, yS) for k in (1, 2)]
    print(f"{ad:<13} {S[ad][0]:>8.4f} {S[ad][1]:>8.4f} {S[ad][1] - S[ad][0]:>+8.4f}")
ilk = [v[0] for v in S.values()]
en = max(abs(v[1] - v[0]) for v in S.values())
print(f"siranin oynattigi (ayni ilklendirme, dort sira) {max(ilk) - min(ilk):.4f} "
      f"({round((max(ilk) - min(ilk)) * len(XS))} abone)")
print(f"ilklendirmenin oynattigi (ayni sira, iki kosum) en cok {en:.4f} "
      f"({round(en * len(XS))} abone)")
SIRA = DIZI["her tur A"]

toplu sirasi   kosum 1  kosum 2     fark
sirasiz         0.8056   0.7897  -0.0159
bir kez         0.8016   0.8016  +0.0000
her tur A       0.8095   0.7937  -0.0159
her tur B       0.8016   0.8056  +0.0040
siranin oynattigi (ayni ilklendirme, dort sira) 0.0079 (2 abone)
ilklendirmenin oynattigi (ayni sira, iki kosum) en cok 0.0159 (4 abone)

Dört sıra, aynı ağ, aynı 400 güncelleme: sınama sayıları 0,8056, 0,8016, 0,8095 ve 0,8016. Sıranın oynattığı 0,0079, iki abone. Bu bir bulgu değildir ama bir karardır: hangi sıra seçilirse seçilsin gerekçesi yazılmalıdır, çünkü sonucu oynatır.

Aynı tablo ikinci sütunuyla okunduğunda ölçek yerine oturuyor. Sıra sabit tutulup yalnız başlangıç değerleri değiştiğinde fark 0,0159’a, dört aboneye çıkıyor — sıranın oynattığının iki katı. “Sırasız” ve “her tur A” satırlarında ikinci koşum birincinin dört abone altına düşüyor, “bir kez” satırında iki koşum tıpatıp aynı sayıyı veriyor. Aynı satırda iki koşumun eşit çıkması, sıranın etkisiz olduğunu değil, iki koşumun bütün koşumlar olmadığını gösterir.

Veri Artırma

# Veri artirma: surekli dort sutuna gurultu eklenmis KOPYA satirlar; gurultu
# olcegi standart sapma birimindedir. GUNCELLEME SAYISI 400'de SABIT tutulur —
# artirilmis kume iki kat buyuk oldugu icin tur sayisi yariya iner.
def artir(X, y, tohum, sapma):
    r, XA, yA = uretec(tohum), list(X), list(y)
    for k in range(len(X)):
        v = list(X[k])
        for j in range(4, 8):
            v[j] += (r() + r() + r() - 1.5) * 2 * sapma
        XA.append(v)
        yA.append(y[k])
    return XA, yA


MODEL, ORT = {}, {}
print(f"{'artirma':<13} {'satir':>6} {'tur':>4} {'kosum1':>7} {'kosum2':>7} "
      f"{'kosum3':>7} {'ort':>7}")
for sapma in (0.0, 0.05, 0.15, 0.40):
    XA, yA = (XE, yE) if sapma == 0.0 else artir(XE, yE, TOHUM + 11000, sapma)
    MODEL[sapma] = [egit(XA, yA, TOHUM + k, SIRA) for k in (1, 2, 3)]
    r = [dogruluk(p, XS, yS) for p in MODEL[sapma]]
    ORT[sapma] = sum(r) / len(r)
    ad = "yok" if sapma == 0.0 else f"sapma {sapma:.2f}"
    print(f"{ad:<13} {len(XA):>6} {400 // (len(XA) // 30):>4} "
          + " ".join(f"{v:>7.4f}" for v in r) + f" {ORT[sapma]:>7.4f}")
for sapma in (0.05, 0.15, 0.40):
    print(f"artirmanin kattigi (sapma {sapma:.2f}) {ORT[sapma] - ORT[0.0]:+.4f}")

artirma        satir  tur  kosum1  kosum2  kosum3     ort
yok              300   40  0.8095  0.7937  0.8016  0.8016
sapma 0.05       600   20  0.8016  0.8095  0.8016  0.8042
sapma 0.15       600   20  0.8016  0.8095  0.7976  0.8029
sapma 0.40       600   20  0.7937  0.7937  0.7937  0.7937
artirmanin kattigi (sapma 0.05) +0.0026
artirmanin kattigi (sapma 0.15) +0.0013
artirmanin kattigi (sapma 0.40) -0.0079

Artırmanın kattığı fark üç koşumun ortalamasından okunur: gürültü 0,05 iken +0,0026, 0,15 iken +0,0013, 0,40 iken −0,0079. İlk ikisi artı, üçüncüsü eksi; ama üçü de artırmasız kurulumun kendi koşum aralığından (0,7937–0,8095, yani 0,0158) küçüktür. Bu tabloda dürüst cümle şudur: artırma bu veride ölçülebilir bir fark katmıyor. Katkı sıfırdan ayırt edilemiyor, çünkü aynı kurulumun iki koşumu arasındaki fark katkıdan büyük.

Son satırda başka bir şey görünüyor. Gürültü 0,40’a çıktığında üç koşum da tıpatıp aynı sayıyı veriyor: 0,7937. Kuvvetli gürültü bir düzenlileştirme gibi davranıp başlangıç değerlerinin açtığı farkı siliyor, ama sildiği farkla birlikte kazancı da siliyor. Ağın gördüğü satır sayısı iki kat arttı; tur sayısı yarıya indiği için attığı eğim adımı aynı kaldı ve artırmanın kazandırdığı çeşitlilik, kaybettirdiği sinyalden büyük çıkmadı.

Artırmanın Sızdırdığı Yer

Artırma bir sıra kararıdır. Doğru sıra böl, sonra artır: kopyalar yalnız eğitim satırlarından türetilir. Yanlış sıra artır, sonra böl: bir sınama satırının gürültülü ikizi eğitim kümesine düşer ve ağ o satırı neredeyse görmüş olur.

# SIZINTI: artirma BOLMEDEN ONCE yapilirsa sinama satirinin gurultulu ikizi
# egitim kumesine girer (M27/K02, veri sizintisi). Sinama kumesi iki kurulumda
# da AYNI 252 orijinal satirdir; kaydirma alt kume karsilastirmasindan okunur.
def sizintili(sapma, tohum):
    r, XA, yA = uretec(tohum), list(XE), list(yE)
    havuz = karistir(range(len(XE) + len(XS)), tohum + 5)[:len(XE)]
    for k in havuz:
        x, e = (XE[k], yE[k]) if k < len(XE) else (XS[k - len(XE)], yS[k - len(XE)])
        v = list(x)
        for j in range(4, 8):
            v[j] += (r() + r() + r() - 1.5) * 2 * sapma
        XA.append(v)
        yA.append(e)
    return XA, yA, sorted(k - len(XE) for k in havuz if k >= len(XE))


def alt(p, idx):
    return dogruluk(p, [XS[k] for k in idx], [yS[k] for k in idx])


XL, yL, IKIZ = sizintili(0.05, TOHUM + 11000)
TEMIZ = [k for k in range(len(XS)) if k not in set(IKIZ)]
print(f"sinama kumesinin {len(IKIZ)} satirinin ikizi egitim kumesinde, "
      f"{len(TEMIZ)} satirinki degil")
print(f"{'egitim':<11} {'kosum':>5} {'hepsi':>7} {'ikizli':>7} {'temiz':>7} {'fark':>8}")
K = {}
for ad, P in (("durust", MODEL[0.05]),
              ("sizintili", [egit(XL, yL, TOHUM + k, SIRA) for k in (1, 2, 3)])):
    K[ad] = []
    for k, p in enumerate(P, 1):
        a, b = alt(p, IKIZ), alt(p, TEMIZ)
        K[ad].append(a - b)
        print(f"{ad:<11} {k:>5} {dogruluk(p, XS, yS):>7.4f} {a:>7.4f} {b:>7.4f} "
              f"{a - b:>+8.4f}")
d, s = sum(K["durust"]) / 3, sum(K["sizintili"]) / 3
print(f"ikizli-temiz farkinin ortalamasi: durust {d:+.4f}, sizintili {s:+.4f}; "
      f"kayma {s - d:+.4f}")

sinama kumesinin 138 satirinin ikizi egitim kumesinde, 114 satirinki degil
egitim      kosum   hepsi  ikizli   temiz     fark
durust          1  0.8016  0.7899  0.8158  -0.0259
durust          2  0.8095  0.8043  0.8158  -0.0114
durust          3  0.8016  0.7899  0.8158  -0.0259
sizintili       1  0.8095  0.8116  0.8070  +0.0046
sizintili       2  0.8095  0.8043  0.8158  -0.0114
sizintili       3  0.8095  0.8116  0.8070  +0.0046
ikizli-temiz farkinin ortalamasi: durust -0.0211, sizintili -0.0008; kayma +0.0203

Toplam sayılar tek başına okunamıyor: sızıntılı eğitimin üç koşumu 0,8095’te duruyor, dürüst eğitimin üç koşumu 0,8016–0,8095 arasında. Fark koşum aralığının içinde kalıyor ve bu ölçekte sızıntı toplam sayıdan görülmüyor. M27/K02’de aynı türden bir sızıntı ayrılmış küme sayısını 0,0476 şişirmişti.

Alt küme karşılaştırması koşum değişkenliğini iptal ediyor, çünkü iki alt küme aynı koşumdan okunuyor. İkizi eğitim kümesinde olan 138 satır ile ikizi olmayan 114 satır arasındaki fark, dürüst eğitimde ortalama −0,0211: ikizli grup zaten biraz daha zor. Sızıntılı eğitimde aynı fark −0,0008’e çıkıyor. Kayma +0,0203, yani beş abone; ve bu kayma toplam sayıda görünmeyen sızıntının bıraktığı izdir. Sızıntının varlığı toplam sayıdan değil, kimin şiştiğinden okunur.

Özet

• Toplu üretim sırası dört ayrı kararla kurulduğunda sınama sayısı 0,8016 ile 0,8095 arasında değişiyor; sıranın oynattığı 0,0079, iki abone.
• Aynı sırada yalnız başlangıç değerleri değiştiğinde fark 0,0159’a, dört aboneye çıkıyor: koşum değişkenliği sıra kararının iki katı kadar oynatıyor.
• Artırmanın kattığı fark üç koşumun ortalamasında +0,0026, +0,0013 ve −0,0079; üçü de artırmasız kurulumun koşum aralığından küçük, yani katkı sıfırdan ayırt edilemiyor.
• Gürültü 0,40’ta üç koşum da 0,7937 veriyor: kuvvetli artırma başlangıç farkını da kazancı da siliyor.
• Artırma bölmeden önce yapıldığında sınama kümesinin 138 satırının ikizi eğitim kümesine giriyor; toplam sayı şişmeyi göstermiyor ama ikizli-temiz farkı −0,0211’den −0,0008’e kayıyor, kayma +0,0203.

Sonraki Adım

Toplu boyu bu derste otuzda, güncelleme sayısı dört yüzde sabit tutuldu. İkisi de birer karardır ve ikisi de bir kaynağa bağlıdır: bir güncellemede kaç örneğin ileri ve geri geçişinin aynı anda bellekte durabileceğine. Sonraki ders donanım kullanımını ele alır: toplu boyut ile bellekte tutulan sayı adedi arasındaki ilişki hesaplanır ve toplu boyun öğrenme adımıyla birlikte değişmesi gerektiği sayıyla gösterilir.