---
title: 'Veri Yükleme Hattı'
source: 'https://academia.sh/tr/kurslar/derin-ogrenme/veri-yukleme-hatti'
course: 'Derin Öğrenme'
language: tr
updated: '2026-08-17T18:10:11+00:00'
license: 'CC BY-SA 4.0'
---

# Veri Yükleme Hattı

Toplu üretim sırasının, veri artırmanın ve artırmanın ürettiği sızıntının ayrı ayrı ölçülmesi: aynı ağ ve aynı 400 güncellemeyle dört toplu sırası sınama kümesinde 0,8016 ile 0,8095 arasında dört sayı verirken, aynı sırada yalnız başlangıç değerleri değiştiğinde fark 0,0159'a çıkıyor — sıra kararı koşum değişkenliğinin yarısı kadar oynatıyor. Artırmanın kattığı fark üç koşumun ortalamasında +0,0026, +0,0013 ve −0,0079; üçü de tek bir sıranın koşum aralığından küçüktür. Artırma bölmeden önce yapıldığında sınama kümesinin 138 satırının ikizi eğitim kümesine giriyor ve ikizli-temiz alt küme farkı −0,0211'den −0,0008'e kayıyor: kayma +0,0203.

Ö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

```python
# 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.

```python
# 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

```python
# 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.

```python
# 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.
