---
title: 'Etkinleştirme Fonksiyonları'
source: 'https://academia.sh/tr/kurslar/derin-ogrenme/etkinlestirme-fonksiyonlari'
course: 'Derin Öğrenme'
language: tr
updated: '2026-08-17T18:10:08+00:00'
license: 'CC BY-SA 4.0'
---

# Etkinleştirme Fonksiyonları

Etkinleştirme seçiminin doygunluk, ölü birim ve ilk katmana ulaşan eğim üzerinden ölçülmesi: sigmoidin türevi z=1'de 0,1966 iken z=6'da 0,0025'e iner, oran 79,7; hiperbolik tanjantta oran 17.088. Aynı ağda ilk katmana ulaşan ortalama eğim sigmoitle 1,0456, doğrultulmuş doğrusal birimle 4,4498 — 4,26 kat. Üç etkinleştirme ikişer koşumla: sigmoit 0,7937 ve 0,7976, doğrultulmuş 0,7857 ve 0,7698, hiperbolik tanjant 0,7659 ve 0,7698; taban çizgisi 0,7579. Öğrenme adımı 20'ye çıkarıldığında doğrultulmuş birimlerin dördü, 30'da sekizi de ölüyor ve ortalama türev tam olarak 0,0000 oluyor; sigmoit ile hiperbolik tanjantta hiçbir birim ölmüyor ama ortalama türev 0,1971'den 0,0295'e iniyor.

Ö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.

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

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

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