Nöronlar ve aktivasyonlar

Lojistik regresyon girdilerden bir skor hesaplar. Skoru sigmoid’den geçirir ve bir olasılık (probability) verir. Sigmoid, skoru 0 ile 1 arasına sıkıştıran fonksiyondur.

Bu küçük birime nöron (neuron) denir. Sinir ağı, nöronların yoğun katmanlar (dense layer)yoğun katman (dense layer): Her girdinin her nörona bağlandığı katman: girdiler bir ağırlık matrisiyle çarpılır, sapma eklenir ve sonuç bir aktivasyon fonksiyonundan geçer. hâlinde art arda dizilmesiyle kurulur. Böyle katmanlardan oluşan modele çok katmanlı algılayıcı (multilayer perceptron, MLP)çok katmanlı algılayıcı (multilayer perceptron, MLP): Aralarında aktivasyon fonksiyonu bulunan birkaç yoğun katmanın art arda dizilmesiyle kurulan sinir ağı. denir.

Sinir ağının işe yaraması için her nöronun sonunda doğrusal olmayan bir aktivasyon fonksiyonu (activation function)aktivasyon fonksiyonu (activation function): Bir nöronun ağırlıklı toplamını çıktıya çeviren ve ağın doğrusal olmayan fonksiyonlar öğrenebilmesini sağlayan fonksiyon; en bilinenleri sigmoid, tanh, ReLU ve GELU'dur. gerekir. Bu seçim eğitimi doğrudan etkiler. Bazı seçimlerde gradyan (gradient)gradyan (gradient): Bir fonksiyonun en hızlı arttığı yönü ve bu artışın dikliğini gösteren türev vektörü. katmanlardan geçerken erir; buna kaybolan gradyan (vanishing gradient)kaybolan gradyan (vanishing gradient): Gradyanın, türevi küçük aktivasyonlardan geçerek girişe yakın katmanlara ulaşana kadar neredeyse sıfıra inmesi; o katmanlar bu yüzden çok yavaş öğrenir ya da hiç öğrenemez. (vanishing gradient) denir.

Bu derste şunları yapacaksın:

• Nöronu kuracaksın.
• Katmanları (layer) aktivasyon olmadan üst üste koymanın neden bir şey kazandırmadığını göreceksin.
• Dört aktivasyon fonksiyonunu ve türevlerini (derivative) karşılaştıracaksın.
• $K$ sınıflı bir problem için ham skorları (logits) olasılığa çeviren softmax’ı öğreneceksin.
• Çapraz entropiyi (cross-entropy) öğreneceksin.

Bir nöron

Nöron, ağırlıklı bir toplam ve ardından bir aktivasyon fonksiyonudur.

Ağırlıklı toplam ve aktivasyon

Lojistik regresyonun iki adımı vardı:

1. Ağırlıklı toplamı hesapla: girdileri kendi ağırlıklarıyla (weight)ağırlık (weight): Bir girdiyle çarpılarak onun çıktıya ne kadar katkıda bulunacağını belirleyen parametre. Doğrusal modelde her özniteliğin kendi ağırlığı vardır. çarp, topla ve sapmayı (bias)sapma (bias): Girdilerle çarpılmadan çıktıya eklenen parametre. Doğrusal modelde bütün öznitelikler 0 iken modelin verdiği tahmindir. ekle.
2. Çıkan skoru sigmoid’e ver.

Aynı iki adım bir nöronun tanımıdır. $\mathbf{x}$ girdi vektörü, $\mathbf{w}$ weight’ler ve $b$ bias olsun:

Denklemler iki şey tanımlar:

• Birinci denklem ağırlıklı toplamı verir. $z$‘ye aktivasyon öncesi değer (pre-activation) diyeceğiz.
• İkinci denklem $z$‘yi bir $f$ fonksiyonundan geçirir. Çıktı $a$‘dır ve aktivasyon sonrası değer (activation) adını taşır.

$f$ sigmoid olduğunda ortaya lojistik regresyon çıkar. Başka bir $f$ seçersen başka bir nöron elde edersin.

Aşağıda girdileri, weight’leri ve bias’ı kaydır, aktivasyonu değiştir. Başlangıç değerleri örneğimizdir; üçüncü girdi 0’dır.

Sayılarla kuralım: $\mathbf{x} = (2;\ -1)$, $\mathbf{w} = (1{,}5;\ 2)$ ve $b = 0{,}5$ olsun.

1. Ağırlıklı toplamı hesapla: $z = 1{,}5 \cdot 2 + 2 \cdot (-1) + 0{,}5 = 1{,}5$.
2. Sigmoid’i uygula: $\sigma(1{,}5) \approx 0{,}818$.

Nöron bu girdinin 1 sınıfından olduğuna %81,8 olasılık veriyor.

Aynı hesap kodda iki satırdır. f aktivasyon fonksiyonunu parametre olarak alır:

import numpy as npdef sigmoid(z):    return 1 / (1 + np.exp(-z))def neuron(x, w, b, f):    z = w @ x + b     # ağırlıklı toplam    return f(z)       # aktivasyonx = np.array([2.0, -1.0])w = np.array([1.5, 2.0])b = 0.5print(w @ x + b)                 # → 1.5print(neuron(x, w, b, sigmoid))  # → 0.8175744761936437

Aktivasyonsuz nöronlar tek nörona çöker

$f$ olmasa nöron yalnızca $z$ değerini verirdi. Bu, doğrusal bir modeldir. Asıl sorun, nöronlar art arda dizildiğinde ortaya çıkar.

Tek girdili iki nöronu aktivasyonsuz birbirine bağlayalım. Birincisi $z_1 = 2x + 1$, ikincisi $z_2 = 3z_1 - 4$ olsun.

1. Birincinin çıktısını ikincide yerine koy: $z_2 = 3(2x + 1) - 4$.
2. Parantezi aç: $z_2 = 6x - 1$.

Sonuç yine bir doğrudur. Genel olarak:

Sol taraf iki doğrusal adım, sağ taraf tek bir doğrusal adımdır: yeni weight $w_2 w_1$, yeni bias $w_2 b_1 + b_2$.

Aynı sayılarla kodda iki yolu karşılaştır:

w1, b1 = 2.0, 1.0w2, b2 = 3.0, -4.0x = np.array([-1.0, 0.0, 1.0, 2.0])two_steps = w2 * (w1 * x + b1) + b2one_step = (w2 * w1) * x + (w2 * b1 + b2)two_steps                # → array([-7., -1.,  5., 11.])one_step                 # → array([-7., -1.,  5., 11.])(w2 * w1, w2 * b1 + b2)  # → (6.0, -1.0)

Doğrusal adımları ne kadar üst üste koyarsan koy, sonuç tek bir doğrusal adımdır. Aktivasyonsuz yüz layer’lık bir ağ, tek bir layer’dan daha güçlü değildir.

ReLU ile kırılma

Araya bir aktivasyon koyunca bu değişir. Negatif değerleri 0’a çeken $\max(0, z)$ fonksiyonunu seçelim. Adı ReLU’dur; ayrıntısına aşağıda bakacağız.

İlk nöronun çıktısı $a_1 = \max(0, z_1)$ olsun. İkinci nöron $z_2 = 3a_1 - 4$ hesaplasın:

Tablonun son sütununu ve sütunlardaki farkları kodla bul:

# önceki bloktaki np, w1, b1 ve x ilez1 = w1 * x + b1z2 = 3 * z1 - 4         # aktivasyonsuza1 = np.maximum(0, z1)  # ReLU: negatifleri 0 yapz2_relu = 3 * a1 - 4    # ReLU'luz2_relu                 # → array([-4., -1.,  5., 11.])np.diff(z2)             # → array([6., 6., 6.])np.diff(z2_relu)        # → array([3., 6., 6.])

Komşu satırlar arasındaki farka bak:

• Aktivasyonsuz sütunda fark hep 6’dır. Bu, $6x - 1$ doğrusunun eğimidir.
• ReLU’lu sütunda farklar 3, 6, 6 çıkar. $x \le -0{,}5$ iken çıktı sabit $-4$‘tür, ondan sonra $6x - 1$ olur.

Eğim bir noktada 0’dan 6’ya geçiyor ve bir doğru bunu yapamaz.

Evrensel yaklaşım teoremi

Tek bir kırılma küçük görünür. Çok sayıda nöronun kırılmaları birleşince ağ eğri fonksiyonlara yaklaşabilir.

Bu kanıtlanmış bir sonuçtur. Tek bir gizli katmanı (hidden layer) olan bir ağ, sınırlı bir aralıkta sürekli her fonksiyona istenen kadar yaklaşabilir. İki koşul gerekir:

• Aktivasyon fonksiyonu polinom değildir. ReLU, sigmoid ve tanh bu koşulu sağlar.
• Gizli katmanda yeterince nöron vardır.

Teoreme evrensel yaklaşım teoremi (universal approximation theorem) denir. Bu derste kanıtına girmiyoruz.

Küçük bir deneyle görelim. $[0;\ 1]$ aralığında $x^2$ eğrisine $n$ ReLU nöronuyla yaklaşacağız. $h = 1/n$ olsun:

1. $k = 0, 1, \ldots, n-1$ için bir nöron $\max(0,\ x - kh)$ hesaplar. Weight’i 1, bias’ı $-kh$‘dir; $x = kh$‘de kırılır.
2. Nöronların çıktılarını birer weight ile çarpıp topla. Bunlar, yukarıdaki $z_2 = 3a_1 - 4$ hesabındaki 3 gibi çıkış weight’leridir.
3. Her çıkış weight’i, kendi kırılma noktasından sonra eğimi o kadar artırır. $x^2$‘yi $0, h, 2h, \ldots$ noktalarında birleştiren kırık çizginin eğimleri $h, 3h, 5h, \ldots$ olur. Bu yüzden ilk weight $h$, ötekiler $2h$‘dir.

def approx(x, n):    h = 1 / n    out = 0.0    for k in range(n):        w_out = h if k == 0 else 2 * h   # eğim artışı: önce h, sonra 2h        out = out + w_out * np.maximum(0, x - k * h)  # kh'de kırılan ReLU nöronu    return outx = np.linspace(0, 1, 4097)for n in (4, 8, 16):    print(n, np.abs(approx(x, n) - x ** 2).max())# → 4 0.015625# → 8 0.00390625# → 16 0.0009765625

Bu deneyde nöron sayısı iki katına çıkınca en büyük hata dörtte birine düşer. Weight’leri burada elle seçtik. Teorem böyle weight’lerin var olduğunu söyler; onları veriden bulmak eğitimin işidir.

Dört aktivasyon fonksiyonu

Pratikte dört aktivasyon fonksiyonu sık karşına çıkar: sigmoid, tanh, ReLU ve GELU.

Fonksiyonlar ve türevleri

Eğitimde gradyan bu fonksiyonlardan geçer. Bu yüzden her birinin türevine de ihtiyacımız var. Fonksiyonlar şunlardır:

Türevleri ve özellikleri yan yana koyalım:

$\Phi(z)$, standart normal dağılımdan çekilen bir sayının $z$ değerinden küçük olma olasılığıdır. $z$ büyükken 1’e, çok negatifken 0’a yakındır. $\varphi$ ise standart normal dağılımın yoğunluğudur.

Üç fonksiyonu ve türevlerini kodla yaz. relu_grad, $z = 0$ için 0 verir:

import numpy as npdef sigmoid(z):    return 1 / (1 + np.exp(-z))def sigmoid_grad(z):    s = sigmoid(z)    return s * (1 - s)def tanh_grad(z):    return 1 - np.tanh(z) ** 2def relu(z):    return np.maximum(0, z)def relu_grad(z):    return (z > 0).astype(float)    # z = 0 için 0z = np.array([-2.0, 0.0, 3.0])np.round(sigmoid(z), 3)         # → array([0.119, 0.5  , 0.953])np.round(sigmoid_grad(z), 3)    # → array([0.105, 0.25 , 0.045])np.round(np.tanh(z), 3)         # → array([-0.964,  0.   ,  0.995])np.round(tanh_grad(z), 3)       # → array([0.071, 1.   , 0.01 ])relu(z)                         # → array([0., 0., 3.])relu_grad(z)                    # → array([0., 0., 1.])

GELU için $\Phi$ ve $\varphi$ gerekir. $\Phi$‘yi standart kütüphanedeki erf ile yazarız:

from math import erf, sqrt, pidef cdf(z):    # Φ(z) = 0.5 * (1 + erf(z / sqrt(2)))    return 0.5 * (1 + np.vectorize(erf)(z / sqrt(2)))def pdf(z):    # φ(z): standart normal yoğunluk    return np.exp(-z ** 2 / 2) / sqrt(2 * pi)def gelu(z):    return z * cdf(z)def gelu_grad(z):    return cdf(z) + z * pdf(z)z = np.array([-1.0, 1.0])np.round(gelu(z), 2)        # → array([-0.16,  0.84])np.round(gelu_grad(z), 2)   # → array([-0.08,  1.08])

Grafikte fonksiyon ve türev

Aşağıda bir fonksiyon seç ve imleci $z$ ekseni boyunca sürükle. İmlecin altında $f(z)$ ile $f'(z)$ değerini okursun. Türevin sıfıra çok yaklaştığı, yani $-0{,}1$ ile $0{,}1$ arasında kaldığı bölgeler “gradyan kayboluyor” diye gölgelenir.

Şunları dene:

• Sigmoid’de imleci $z = 0$‘a koy: $f = 0{,}5$ ve $f' = 0{,}25$. Sonra $z = 3$‘e sürükle: $f \approx 0{,}95$ iken $f' \approx 0{,}045$. Fonksiyon hâlâ 1’e varmadı, ama eğrisi neredeyse yatay.
• tanh için $z = 0$‘da türev 1, $z = 2$‘de yaklaşık $0{,}07$‘dir. Gölgeli bölge sigmoid’dekinden biraz erken başlar. Sigmoid’de $\lvert z \rvert > 2{,}06$ civarında, tanh’ta $\lvert z \rvert > 1{,}82$ civarında.
• ReLU’da $z = 1$ için $f = 1$ ve $f' = 1$; $z = -1$ için ikisi de 0’dır. Gölgeli bölge, $z$‘nin negatif tarafının tamamıdır.
• GELU’da üç şeye bak:
  • $z = 1$ için $f \approx 0{,}84$ ve $f' \approx 1{,}08$. Türev 1’i aşabilir.
  • $z = -1$ için $f \approx -0{,}16$ ve $f' \approx -0{,}08$. GELU küçük negatif değerler verebilir ve türevi negatif olabilir. ReLU’da böyle bir şey yoktur.
  • GELU’nun negatif tarafında gölgesiz dar bir bant kalır. Türev orada $-0{,}1$ ile $-0{,}13$ arasındadır; küçük ama sıfır değildir.

Gölgenin başladığı $z$ değerini kodla da bulabilirsin. Türevin ilk kez $0{,}1$‘in altına indiği noktaya bak:

# önceki bloklardaki sigmoid_grad ve tanh_grad ilez = np.linspace(0, 5, 5001)print(z[sigmoid_grad(z) < 0.1][0])  # → 2.064print(z[tanh_grad(z) < 0.1][0])     # → 1.819

Vanishing gradient

Gölgeli bölgelerin önemi geri yayılımdan gelir. Bir sonraki derste göreceğin geri yayılımda (backpropagation)geri yayılım (backpropagation): Zincir kuralıyla, kaybın her parametreye göre gradyanını çıkıştan girişe doğru hesaplama yöntemi., kaybın (loss) gradyanı çıkıştan girişe doğru taşınır. Gradyan her layer’dan geçerken o layer’ın aktivasyon türeviyle çarpılır.

Türev küçükse gradyan küçülür. Bir layer’da küçülmesi önemsizdir, ama küçülmeler çarpıldıkça birikir.

Tipik bir layer’da sigmoid’in türevi yaklaşık $0{,}2$‘dir. Örnek olarak $z = 1$ alalım. Orada $\sigma'(1) \approx 0{,}197$ ve $\tanh'(1) \approx 0{,}420$ olur.

Weight’leri 1 sayarsak her layer gradyanı türevle çarpar. On sigmoid layer’dan sonra çarpım $0{,}197^{10} \approx 9 \cdot 10^{-8}$ olur. Girişe ulaşan gradyan, çıkıştakinin on milyonda biri kadardır.

Sigmoid’in türevi en iyi ihtimalle $0{,}25$‘tir ($z = 0$‘da). Gerçek bir ağda $z$ genelde 0’da durmaz, bu yüzden çarpan daha da küçüktür.

Kodda $z = 1$ ile izle:

# önceki bloktaki sigmoid_grad ve tanh_grad ileprint(sigmoid_grad(1.0))    # → 0.19661193324148185print(tanh_grad(1.0))       # → 0.41997434161402614grad = 1.0for layer in range(1, 11):    grad = grad * sigmoid_grad(1.0)  # her layer'da türevle çarp    if layer in (1, 5, 10):        print(layer, grad)# → 1 0.19661193324148185# → 5 0.0002937983603191941# → 10 8.631747652624701e-08

Gradyan weight’lerle de çarpılır. Bu hesap yalnızca aktivasyonların etkisini gösterir. Yine de sigmoid’le gradyan her layer’da erimeye yatkındır.

Aktivasyonu seç ve katman sayısını sürükle.

Gradyanın giriş tarafına ulaşamadan erimesine vanishing gradientkaybolan gradyan (vanishing gradient): Gradyanın, türevi küçük aktivasyonlardan geçerek girişe yakın katmanlara ulaşana kadar neredeyse sıfıra inmesi; o katmanlar bu yüzden çok yavaş öğrenir ya da hiç öğrenemez. denir. Girişe yakın layer’ların weight’leri neredeyse hiç güncellenmez ve ağ öğrenmez.

Yukarıdaki grafikte sigmoid ve tanh’ın gölgeli bölgelerinin iki uçta olduğuna dikkat et. $z$ bu uçlara düştüğünde nöronun çıktısı neredeyse hiç değişmez ve gradyan geçmez.

ReLU ve dying ReLU

ReLU bu yüzden yaygınlaştı. Pozitif tarafta türevi tam 1’dir ve gradyan olduğu gibi geçer. Bedeli negatif taraftır.

Bir nöronun $z$ değeri her girdi için negatifse, türevi hep 0’dır. Gradyan o nöronun weight’lerini hiç güncellemez ve nöron öğrenmeyi bırakır. Buna dying ReLU denir (ölen ReLU).

Örnek: $b = -10$ olan bir nöron, üç girdinin hepsinde negatif $z$ verir:

# önceki bloktaki relu_grad ileX = np.array([[1.0, 2.0], [2.0, 1.0], [3.0, 0.5]])w = np.array([1.0, 1.0])b = -10.0z = X @ w + b       # üç girdi için aktivasyon öncesi değerz                   # → array([-7. , -7. , -6.5])relu_grad(z)        # → array([0., 0., 0.])

GELU’nun türevi

GELU’nun türevi de ReLU gibi pozitif tarafta 1’e yaklaşır. Köşesi yoktur. $z$ çok negatif olmadıkça sıfırdan farklı, küçük bir türev verir.

# önceki bloktaki gelu_grad ilez = np.array([-6.0, -3.0, -1.0, 0.0, 1.0, 3.0])np.round(gelu_grad(z), 3)   # → array([-0.   , -0.012, -0.083,  0.5  ,  1.083,  1.012])

Layer’lar ve MLP

Bir layer, aynı girdiyi gören nöronların yan yana dizilmesidir.

Dense layer

$d_{\text{out}}$ nöronlu bir layer’da her nöronun kendi weight vektörü ve kendi bias’ı vardır.

Hesabı matrislere şöyle dökeriz:

1. Weight vektörlerini $W$ matrisinin sütunlarına koy.
2. Bias’ları $\mathbf{b}$ vektörüne koy.
3. $N$ örnekten (sample) oluşan bir yığını (batch) $X$ matrisine koy. $X$‘in her satırı bir örnektir.

Böylece bütün nöronların ağırlıklı toplamı tek bir matris çarpımı (matrix product) olur:

Formül her örneği her nöronun weight’iyle çarpıp toplar, bias’ı ekler ve aktivasyonu uygular. Şekiller (shape) şöyledir:

• $X$: $N \times d_{\text{in}}$.
• $W$: $d_{\text{in}} \times d_{\text{out}}$.
• $\mathbf{b}$: $d_{\text{out}}$ elemanlı.
• $Z$ ve $A$: $N \times d_{\text{out}}$.

Matris çarpımında soldakinin sütun sayısı sağdakinin satır sayısına eşit olmalıdır. Bu yüzden $d_{\text{in}}$ iki yanda da aynı kalır.

Layer $\mathbf{b}$‘yi her satıra ekler. NumPy’da buna yayınlama (broadcasting) denir. Layer aktivasyonu $Z$ matrisinin her elemanına ayrı ayrı, yani eleman bazında (element-wise), uygular.

Her girdinin her nörona bağlandığı bu layer’a dense layeryoğun katman (dense layer): Her girdinin her nörona bağlandığı katman: girdiler bir ağırlık matrisiyle çarpılır, sapma eklenir ve sonuç bir aktivasyon fonksiyonundan geçer. denir.

Bir gizli nörona tıkla ve onun weight’lerinin $W$‘nin hangi sütunu olduğuna bak.

Küçük bir örnek: 2 örnek, 3 girdi, 2 nöron.

$X$ matrisi $2 \times 3$, $W$ matrisi $3 \times 2$‘dir. Ortadaki 3’ler eşleşir ve sonuç $2 \times 2$ olur.

$f$ ReLU ise negatif eleman sıfırlanır. $A$‘nın ilk satırı $(3{,}5;\ 0)$, ikincisi $(2{,}5;\ 1)$ olur.

Aynı örnek NumPy’da tek satırlık bir matris çarpımıdır:

import numpy as npX = np.array([[1.0, 2.0, 0.0],              [-1.0, 1.0, 2.0]])W = np.array([[1.0, -1.0],              [1.0, 2.0],              [1.0, 1.0]])b = np.array([0.5, -4.0])Z = X @ W + b                 # b her satıra yayınlanırZ# → array([[ 3.5, -1. ],#          [ 2.5,  1. ]])A = np.maximum(0, Z)          # ReLU, eleman bazındaA# → array([[3.5, 0. ],#          [2.5, 1. ]])(X.shape, W.shape, Z.shape)   # → ((2, 3), (3, 2), (2, 2))

Aktivasyonsuz layer’lar çöker

Aktivasyonsuz nöronların çökmesi, layer’lar için de geçerlidir. Aktivasyon yoksa iki dense layer tek bir layer’a çöker:

Sağ taraftaki tek layer’ın weight matrisi $W^{(1)}W^{(2)}$, bias’ı $\mathbf{b}^{(1)}W^{(2)} + \mathbf{b}^{(2)}$‘dir. Üst indis hangi layer’ın olduğunu gösterir.

Rastgele sayılarla iki tarafı karşılaştır:

rng = np.random.default_rng(0)X = rng.normal(size=(4, 3))W1, b1 = rng.normal(size=(3, 5)), rng.normal(size=5)W2, b2 = rng.normal(size=(5, 2)), rng.normal(size=2)two_layers = (X @ W1 + b1) @ W2 + b2one_layer = X @ (W1 @ W2) + (b1 @ W2 + b2)np.allclose(two_layers, one_layer)   # → True(W1 @ W2).shape                      # → (3, 2)

MLP

Bu yüzden layer’ların arasına aktivasyon koyarız. Dense layer’lardan ve aralarındaki aktivasyonlardan oluşan ağa MLPçok katmanlı algılayıcı (multilayer perceptron, MLP): Aralarında aktivasyon fonksiyonu bulunan birkaç yoğun katmanın art arda dizilmesiyle kurulan sinir ağı. denir. Girdi ile çıkış arasında kalan layer’lara gizli katman (hidden layer) denir.

Sınıflandırma (classification) için tipik bir MLP’ye bakalım. 8×8’lik bir rakam görüntüsü 64 öznitelik (feature) verir. Ağın 32 nöronlu bir hidden layer’ı ve 10 sınıfı olsun:

Son layer’a aktivasyon koymayız: $Z$, her örnek için 10 logit’tir.

Bu ağın parametre (parameter) sayısı $64 \cdot 32 + 32 + 32 \cdot 10 + 10 = 2410$‘dur. Kodda her layer’ın W ve b boyutlarını topla:

d_in, d_hidden, d_out = 64, 32, 10n_params = d_in * d_hidden + d_hidden + d_hidden * d_out + d_outprint(n_params)   # → 2410

İleri geçiş

Girdiden çıktıya giden bu hesaba ileri geçiş (forward pass) denir. Kodda üç satırdır:

def forward(X, W1, b1, W2, b2):    Z1 = X @ W1 + b1          # ilk layer'ın ağırlıklı toplamı, (n, 32)    A1 = np.maximum(0, Z1)    # aktivasyon, Z1'in her elemanına ayrı ayrı    logits = A1 @ W2 + b2     # son layer, aktivasyonsuz, (n, 10)    return logitsrng = np.random.default_rng(0)X = rng.normal(size=(5, 64))W1, b1 = rng.normal(size=(64, 32)), np.zeros(32)W2, b2 = rng.normal(size=(32, 10)), np.zeros(10)forward(X, W1, b1, W2, b2).shape                 # → (5, 10)sum(p.size for p in (W1, b1, W2, b2))            # → 2410

Weight’lerin nasıl öğrenildiğini Geri yayılım dersinde göreceksin. Ardından ileride bir MLP’yi eğitmeye geçeceğiz.

Softmax

Softmax, $K$ skoru $K$ sınıf üzerinde bir olasılık dağılımına çevirir.

Softmax formülü

Sınıf sayısı $K$ olduğunda son layer $K$ logit verir. Lojistik regresyonda tek bir skoru sigmoid’le olasılığa çeviriyordun; $K$ sınıfta aynı işi softmax yapar.

Adı, “en büyüğünü seç” işlemini yumuşatmasından gelir. En büyük skora en büyük olasılığı verir, ama diğerlerini sıfırlamaz.

Üstel fonksiyon her skoru pozitif yapar. Bölme toplamı 1’e getirir. Sonuç, $K$ sınıf üzerinde bir olasılık dağılımıdır.

$\mathbf{z} = (2;\ 1;\ 0)$ için hesap şöyledir:

1. Skorların üstelini al: $e^2 \approx 7{,}389$, $e^1 \approx 2{,}718$ ve $e^0 = 1$.
2. Üstelleri topla: $11{,}107$.
3. Her üsteli toplama böl: $\mathbf{p} \approx (0{,}665;\ 0{,}245;\ 0{,}090)$.

Olasılıkların oranı yalnızca skorların farkına bağlıdır: $p_a / p_b = e^{z_a - z_b}$. Skorlar arasındaki fark 1 arttığında oran $e \approx 2{,}72$ katına çıkar.

Aynı üç adım kodda üç satırdır:

import numpy as npz = np.array([2.0, 1.0, 0.0])exps = np.exp(z)exps                   # → array([7.3890561 , 2.71828183, 1.        ])print(exps.sum())      # → 11.107337927389695probs = exps / exps.sum()probs                  # → array([0.66524096, 0.24472847, 0.09003057])print(probs[0] / probs[1])   # → 2.7182818284590455

İki sınıfta softmax

$K = 2$ olduğunda softmax sigmoid’e iner:

Yani iki sınıfta softmax, skorların farkına uygulanan sigmoid’dir.

İki skor seç ve iki yolla hesapla. Fark 1,5 olduğundan sonuç, nöron örneğindeki $0{,}818$‘dir:

# önceki bloklardaki np ve sigmoid ilez0, z1 = 0.3, 1.8exps = np.exp([z0, z1])print(np.round(exps[1] / exps.sum(), 4))   # → 0.8176print(np.round(sigmoid(z1 - z0), 4))       # → 0.8176

Taşma

Büyük skorlarda üstel fonksiyon taşar. $\mathbf{z} = (1000;\ 1001;\ 1002)$ olsun. $e^{1000}$ 64 bitlik bir float’a sığmaz.

$e^{x}$ ancak $x \approx 709{,}78$‘e kadar temsil edilir. Taşma (overflow) olur, sonuç inf çıkar ve inf / inf nan verir.

z = np.array([1000.0, 1001.0, 1002.0])# exp taşar; NumPy RuntimeWarning verirnp.exp(z)                      # → array([inf, inf, inf])np.exp(z) / np.exp(z).sum()    # → array([nan, nan, nan])

En büyüğünü çıkarmak

Çıkış yolu softmax’ın bir özelliğindedir. Her skora aynı $c$ sayısını eklersen $e^{c}$ pay ve paydadan sadeleşir ve olasılıklar değişmez.

Burada $c = -m$ seçelim, $m$ skorların en büyüğü olsun. Örneğimizde $m = 1002$ olur:

1. Skorlardan $m$‘yi çıkar: $(-2;\ -1;\ 0)$.
2. Üstelleri al: $(0{,}135;\ 0{,}368;\ 1)$.
3. Üstelleri topla: $1{,}503$.
4. Her üsteli toplama böl: $(0{,}090;\ 0{,}245;\ 0{,}665)$.

Bu sonuç, $(2;\ 1;\ 0)$ örneğinin tersten yazılmış hâlidir. Üstelini almadan önce skorlardan en büyüğünü çıkar.

# önceki bloktaki z = (1000, 1001, 1002) ileshifted = z - z.max()shifted                   # → array([-2., -1.,  0.])exps = np.exp(shifted)exps                      # → array([0.13533528, 0.36787944, 1.        ])print(exps.sum())         # → 1.5032147244080551exps / exps.sum()         # → array([0.09003057, 0.24472847, 0.66524096])

En büyüğünü çıkarmanın sebebi üç özelliktir:

• Bütün üsler $\le 0$ olur, yani $e^{\cdot} \le 1$ çıkar. Overflow olmaz.
• En büyük skorun üstel değeri tam 1’dir. Toplam en az 1 olur ve sıfıra bölme olmaz.
• Çok küçük üstel değerler 0’a yuvarlanabilir. O sınıfın olasılığı zaten ihmal edilebilir.

Sonuç değişmez, ama hesap sayısal olarak kararlı (numerically stable) olur. Buna sayısal kararlılık (numerical stability) denir.

Üç skoru sürükle, sonra “maksimumu çıkar”ı aç ve olasılıklara bak.

Batch için softmax

Bir batch için fonksiyon, bu adımları her satıra ayrı uygular:

def softmax(logits):    shifted = logits - logits.max(axis=1, keepdims=True)    exps = np.exp(shifted)    return exps / exps.sum(axis=1, keepdims=True)Z = np.array([[2.0, 1.0, 0.0],              [1000.0, 1001.0, 1002.0]])softmax(Z)# → array([[0.66524096, 0.24472847, 0.09003057],#          [0.09003057, 0.24472847, 0.66524096]])softmax(Z).sum(axis=1)               # → array([1., 1.])Z.max(axis=1).shape                  # → (2,)Z.max(axis=1, keepdims=True).shape   # → (2, 1)

Çok sınıflı cross-entropy

Cross-entropy, kendinden emin ve yanlış olmanın bedelidir. Lojistik regresyonda ikili çapraz entropi (binary cross-entropy), modelin doğru sınıfa verdiği olasılık küçüldükçe büyüyen bir kayıp fonksiyonuydu (loss function)kayıp fonksiyonu (loss function): Modelin tahminlerinin ne kadar yanlış olduğunu tek bir sayıyla ölçen fonksiyon.. Aynı fikir $K$ sınıfa taşınır ve adı cross-entropy olarak kalır.

Doğru sınıfın eksi logaritması

Etiketler (label) $0, 1, \ldots, K-1$ arasında tam sayıdır. $P$ softmax çıktısı olsun; $\log$ doğal logaritmadır. $i$. örneğin doğru sınıfı $y_i$ ise loss, modelin o sınıfa verdiği olasılığın eksi logaritmasıdır:

Simgeler şunlardır:

• $P_{i,\,y_i}$, $P$‘nin $i$. satırındaki $y_i$. sütunudur.
• $\ell_i$ tek bir örneğin loss’udur.
• $L$ batch’in ortalamasıdır.

Doğru sınıfa verilen olasılık 1 ise loss 0’dır. Bu olasılık 0’a giderse loss sonsuza gider.

Yukarıdaki $\mathbf{p}$ için (yuvarlanmamış olasılıklarla) loss, doğru sınıfa göre değişir:

Modelin en çok güvendiği sınıf doğruysa loss küçük, en az güvendiği sınıf doğruysa büyüktür.

import numpy as npz = np.array([2.0, 1.0, 0.0])probs = np.exp(z) / np.exp(z).sum()-np.log(probs)    # → array([0.40760596, 1.40760596, 2.40760596])

İki örnekli bir batch alalım:

1. İlk satır $(2;\ 1;\ 0)$, doğru sınıf 0: $\ell_1 = 0{,}4076$.
2. İkinci satır $(0;\ 0;\ 0)$, doğru sınıf 1: model her sınıfa $1/3$ verir ve $\ell_2 = \log 3 \approx 1{,}0986$ olur.
3. Ortalamayı al: $L = (0{,}4076 + 1{,}0986)/2 \approx 0{,}7531$.

NumPy’da probs[np.arange(n), y], her satırdan doğru sınıfın olasılığını seçer:

logits = np.array([[2.0, 1.0, 0.0],                   [0.0, 0.0, 0.0]])y = np.array([0, 1])n = len(y)probs = softmax(logits)                 # önceki bölümdeki softmaxp_true = probs[np.arange(n), y]         # her satırdan doğru sınıfp_true                                  # → array([0.66524096, 0.33333333])losses = -np.log(p_true)losses                                  # → array([0.40760596, 1.09861229])print(losses.mean())                    # → 0.7531091265562451

Her sınıfa $1/K$ veren, yani hiçbir şey bilmeyen bir modelin loss’u her örnekte $\log K$ olur. $K = 10$ için $\log 10 \approx 2{,}303$ çıkar.

Bundan yüksek bir loss, modelin her sınıfa eşit olasılık veren bir modelden bile kötü olduğunu gösterir. $\log K$ bir kıyas noktasıdır.

print(np.log(3))     # → 1.0986122886681098print(np.log(10))    # → 2.302585092994046

One-hot yazılışı

Kitaplarda aynı şey one-hot label’larla yazılır. One-hot label, doğru sınıfta 1, ötekilerde 0 olan satırdır.

Her satırda tek bir 1 olduğundan toplamda yalnızca doğru sınıfın terimi kalır.

# önceki bloktaki y ve probs ileY = np.eye(3)[y]    # her satır bir one-hot labelY# → array([[1., 0., 0.],#          [0., 1., 0.]])-(Y * np.log(probs)).sum(axis=1)    # → array([0.40760596, 1.09861229])

Logaritmanın tuzağı

Formülü olduğu gibi hesaplamak üç adımdır:

1. Skorları hesapla.
2. Softmax al.
3. Logaritma al.

Son adım tehlikelidir. $\mathbf{z} = (0;\ 800;\ 0)$ ve doğru sınıf 0 olsun. En büyüğü çıkarıp softmax alsak bile $e^{-800}$ 0’a yuvarlanır.

Bu durumda $P_{0} = 0$ olur ve $-\log 0 = \infty$ çıkar. Oysa gerçek loss sonludur ve $800$‘e yakındır.

Bu, binary cross-entropy’de gördüğün $\log(0)$ tuzağının aynısıdır. Orada olasılığı $\epsilon = 10^{-12}$ ile kırpmıştık. Burada kırpma loss’u $-\log\epsilon \approx 27{,}6$‘da keser, oysa doğru değer 800’dür.

logits = np.array([[0.0, 800.0, 0.0]])probs = softmax(logits)      # Softmax bölümündeki fonksiyonprobs                       # → array([[0., 1., 0.]])print(-np.log(probs[0, 0])) # → infprint(-np.log(1e-12))       # → 27.631021115928547

Logit’lerden doğrudan loss

Çıkış yolu, olasılığı hiç hesaplamamaktır. Logaritma bir bölümü farka çevirir:

Böylece tek bir örneğin loss’u doğrudan skorlardan yazılır:

Formül, doğru sınıfın skorunu çıkarır ve bütün skorların üstel toplamının logaritmasını ekler. Doğru sınıfın skoru toplama göre ne kadar geride kalıyorsa loss o kadar büyür.

Örneğin $(2;\ 1;\ 0)$ için $\log 11{,}107 \approx 2{,}4076$ olur. Doğru sınıf 0 ise $\ell = -2 + 2{,}4076 = 0{,}4076$ çıkar. Bu, yukarıdakiyle aynıdır.

Tehlikeli kısım, skorların üstel toplamının logaritmasıdır. Orada da aynı yöntemi kullanırız. Toplamı, en büyük skor $m$ ile şöyle yazarız:

Logaritmayı alırsak şunu elde ederiz:

Logaritmanın içindeki toplamda en büyük terim tam 1’dir. Bu yüzden toplam en az 1’dir. $\log(0)$ hiç oluşmaz ve üstel değerler taşmaz.

$(0;\ 800;\ 0)$ örneğinde şunu yaparız:

1. En büyük skoru bul: $m = 800$.
2. İçerideki toplamı hesapla: $1 + 2e^{-800} \approx 1$.
3. Loss’u yaz: $\ell = -0 + 800 = 800$.

Sonuç sonsuz değil, doğru değerdir.

Aynı yöntem iki yerde işe yarar: en büyük skoru çıkar. İki hesap da koda dökülür:

def log_sum_exp(logits):    m = logits.max(axis=1, keepdims=True)    return m[:, 0] + np.log(np.exp(logits - m).sum(axis=1))def cross_entropy(logits, y):    n = logits.shape[0]    return float(np.mean(log_sum_exp(logits) - logits[np.arange(n), y]))log_sum_exp(np.array([[2.0, 1.0, 0.0]]))                    # → array([2.40760596])cross_entropy(np.array([[2.0, 1.0, 0.0]]), np.array([0]))   # → 0.4076059644443806cross_entropy(np.array([[0.0, 800.0, 0.0]]), np.array([0])) # → 800.0

Özet

• Bir nöron, $z = \mathbf{w}^\top \mathbf{x} + b$ ağırlıklı toplamını bir aktivasyon fonksiyonundan geçirir: $a = f(z)$. $f$ sigmoid ise ortaya lojistik regresyon çıkar.
• Aktivasyonsuz layer’lar üst üste konunca sonuç tek bir doğrusal layer’dır. Araya konan doğrusal olmayan bir fonksiyon, ağın eğri fonksiyonları öğrenebilmesini sağlar.
• Bir dense layer $Z = XW + \mathbf{b}$ hesaplar ($W$: (d_in, d_out)). Aktivasyon $Z$ matrisine eleman bazında uygulanır. Dense layer’ları aktivasyonlarla art arda dizersen MLP elde edersin.
• Sigmoid ve tanh’ın türevi uçlarda sıfıra yaklaşır. Bu küçük türevler layer’lar boyunca çarpılınca gradyan kaybolur ve girişe yakın layer’lar öğrenemez. ReLU’nun türevi pozitif tarafta 1, negatif tarafta 0’dır; hep negatif kalan bir nöron öğrenmeyi bırakır.
• Softmax $K$ skoru olasılığa çevirir. Cross-entropy doğru sınıfın olasılığının eksi logaritmasını alır. Üstelini almadan önce en büyük skoru çıkarmak sonucu değiştirmeden taşmayı önler.

Terimler