Tensorhane
Sıradaki

L2 cezası

Zorluk: Kolay

düzenlileştirme

L2 cezası (L2 penalty), weight’lerin (ağırlık) karelerinin toplamıyla orantılı bir terimdir; loss’a (kayıp) eklenir ve büyük weight’leri cezalandırır. Bu, bir düzenlileştirme (regularization) yöntemidir; gradyana yansıması weight decay (ağırlık azaltma) olarak bilinir.

l2_penalty(W, lam) fonksiyonunu yaz. W herhangi bir şekilde (shape) bir weight dizisidir (array), lam ceza katsayısı λ\lambda‘dır. Fonksiyon iki şey hesaplar: cezanın kendisini ve cezanın W’ye göre gradyanını.

R(W)=λ2∑i,jWij2,∂R∂W=λWR(W) = \frac{\lambda}{2}\sum_{i,j} W_{ij}^2, \qquad \frac{\partial R}{\partial W} = \lambda W

Yani ceza, tüm weight’lerin karelerinin toplamının λ/2\lambda/2 katıdır; gradyanı ise her weight’in kendisinin λ\lambda katıdır. (ceza, dW) çiftini tuple olarak döndür: ceza tek bir Python float, dW ise W ile aynı shape’te bir array.

Örnekler

Girdi: W = [[1.0, -2.0], [3.0, 0.5]], lam = 0.1
Çıktı: (0.7125, array([[ 0.1 , -0.2 ], [ 0.3 , 0.05]]))

Girdi: W = [3.0, -4.0], lam = 1.0
Çıktı: (12.5, array([ 3., -4.]))

Girdi: W = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]], lam = 0.5
Çıktı: (0.0, array([[0., 0., 0.], [0., 0., 0.]]))

İpucu 1

np.sum(W ** 2), W’nin tüm elemanlarının karelerini toplayıp tek bir sayı verir. Kare almak işareti kaldırır: negatif weight’ler da cezayı artırır.

İpucu 2

Cezanın önündeki çarpan λ/2\lambda/2‘dir. lam * np.sum(W ** 2) bunun iki katını verir.

İpucu 3

Kareler toplamının her weight’e göre türevi 2Wij2W_{ij}‘dir; λ/2\lambda/2 ile çarpınca λWij\lambda W_{ij} kalır. Gradyan, W’nin lam katıdır.

Gereksinimler

  • W herhangi bir shape’te olabilir (vektör ya da matris); lam bir sayıdır.
  • Dönüş değeri (ceza, dW) tuple’ı. Ceza tek bir float olmalı, array değil; np.sum’ın verdiği np.float64 de kabul edilir.
  • Cezada λ/2\lambda/2 çarpanı vardır, yalnızca λ\lambda değil. Böylece gradyan temiz çıkar: λW\lambda W.
  • dW, W ile aynı shape’te yeni bir array’dir; W’nin kendisi olmamalı.
  • W’yi değiştirme. Fonksiyon bittiğinde çağıran kodun array’i aynı kalır.
  • Weight’ler üzerinde döngü kullanma: NumPy ifadeleri yeter.

L2 penalty, büyük weight’leri pahalı yapar. Eğitimde toplam loss Ltoplam=L+R(W)L_{\text{toplam}} = L + R(W) olur. Veriye uymak için weight’leri büyütmek artık ceza getirir, bu yüzden model daha küçük weight’lerle yetinir ve overfitting azalır.

Bir örnekle hesapla. W=[3,−4]W = [3, -4] ve λ=2\lambda = 2 olsun. Kareler toplamı 9+16=259 + 16 = 25 olur. Ceza 22⋅25=25\tfrac{2}{2}\cdot 25 = 25, gradyan 2⋅[3,−4]=[6,−8]2\cdot[3, -4] = [6, -8]‘dir.

Gradyanın λW\lambda W olması, her güncellemenin weight’i sıfıra doğru çektiği anlamına gelir. Öğrenme oranı (learning rate) η\eta ile adım W←W−η λW=(1−ηλ)WW \leftarrow W - \eta\,\lambda W = (1 - \eta\lambda)W olur: weight her adımda biraz küçülür. Bu yüzden yöntemin adı weight decay’dir.

Cezanın yalnızca weight’lere uygulandığını bil: sapmalara (bias) genelde uygulanmaz.

Daha fazlası için Normalizasyon ve düzenlileştirme dersine bak.

Cezayı λ2\tfrac{\lambda}{2} ile kareler toplamının çarpımı olarak hesapla; gradyan λW\lambda W‘dir:

import numpy as npdef l2_penalty(W: np.ndarray, lam: float) -> tuple[float, np.ndarray]:    penalty = 0.5 * lam * np.sum(W ** 2)    dW = lam * W    return float(penalty), dW

Sık yapılan hata, λ/2\lambda/2 yerine λ\lambda kullanıp gradyanı da buna uydurmamaktır. Ceza λ∑W2\lambda\sum W^2 ise gradyan 2λW2\lambda W olur; ikisinin tutarlı olması gerekir. Bu problemde ceza λ2∑W2\tfrac{\lambda}{2}\sum W^2 ve gradyan λW\lambda W‘dir.

Bir diğer hata kareler toplamı yerine toplamın karesini almaktır (np.sum(W) ** 2): +3+3 ile −3-3 birbirini götürür.

Bu problemde bir sorun mu var?

solution.py
import numpy as npdef l2_penalty(W: np.ndarray, lam: float) -> tuple[float, np.ndarray]:    """W'nin L2 cezasını ve bu cezanın W'ye göre gradyanını döndürür."""    # Kodunu buraya yaz.    return 0.0, np.zeros_like(W)

İçindekiler

Geri bildirim

Tür