Gradyan kontrolü

Bir gradyanı (gradient) elle türetirken işareti, bir çarpanı ya da bir ekseni kaçırmak kolaydır. Hatayı yakalamanın güvenilir yolu, elle türetilen analitik gradyanı (analytic gradient) sayısal gradyanla (numerical gradient) karşılaştırmaktır. Buna gradyan kontrolü (gradient check) denir.

gradient_check(f, grad_f, x, h=1e-5) fonksiyonunu yaz. f, bir NumPy dizisi (array) alıp tek bir sayı döndürür.

grad_f, aynı dizi için f’nin elle türetilmiş gradyanını, x ile aynı şekle (shape) sahip bir dizi olarak döndürür. İki gradyanı hesapla:

• Analitik gradyan $\mathbf{g}_a$, grad_f(x)’tir.
• Sayısal gradyan $\mathbf{g}_n$, merkezi farklarla (central differences) bulunur.

x’in her elemanı $x_i$ için sayısal gradyan şudur:

$\mathbf{e}_i$, yalnızca $i$. elemanı 1, diğerleri 0 olan dizidir. Yalnızca $x_i$‘yi $h$ kadar artırıp azaltırsın. Sonra ikisinin göreli hatasını (relative error) float olarak döndür:

$\lVert \cdot \rVert_2$, bir dizinin bütün elemanlarının karelerinin toplamının karekökü demektir. x iki boyutluysa da bütün elemanlar tek bir liste gibi sayılır.

Hatanın değeri şöyledir:

• İki gradyan aynıysa hata $0$‘dır.
• Gradyanlar birbirinden uzaklaştıkça hata artar, en çok $1$‘e kadar.
• İki gradyan da sıfır dizisiyse payda $0$ olur. Bu durumda hata 0.0’dır.

Test durumlarında f ve grad_f birer isimle verilir. Testler her ismi fonksiyona, x’i de NumPy dizisine çevirir. Sonra üçünü senin fonksiyonuna verir.

f için isimler şunlardır:

grad_f için isimler şunlardır:

Örnekler

Gereksinimler

• f bir dizi alıp tek bir sayı, grad_f(x) de x ile aynı shape’te bir dizi döndürür. x bir ya da iki boyutlu olabilir.

• Dönüş değeri tek bir float: array ya da liste değil. np.float64 de kabul edilir. float(...) ile çevirmek zorunda değilsin.

• İki gradyan da sıfırsa 0.0 döndür. nan ya da hata değil. Paydaya küçük bir sabit ekleme. Formülü olduğu gibi uygula.

• Sayısal gradyanda merkezi farkı ve verilen h’yi kullan. İleri fark testleri geçecek kadar yakın sonuç vermez. Formülü şudur:

  $$\frac{f(\mathbf{x} + h\,\mathbf{e}_i) - f(\mathbf{x})}{h}$$

• x tam sayılardan oluşan bir array de olabilir. Sayısal gradyan yine float hesaplanmalı.

• x’i değiştirme. Fonksiyon bittiğinde çağıran kodun array’i aynı kalmalı.

Gradyan kontrolü, yanlış türetilmiş bir gradyanı göreli hatayla yakalar. Doğru gradyanı $2\mathbf{x}$ olan şu fonksiyonu alalım:

Sen yanlışlıkla $3\mathbf{x}$ yazdın. $\mathbf{x} = (1, -2, 3)$ için hesap şöyledir:

1. Analitik gradyan: $\mathbf{g}_a = (3, -6, 9)$.

2. Sayısal gradyan: yaklaşık $\mathbf{g}_n = (2, -4, 6)$.

3. Fark: $(1, -2, 3)$.

4. Normlar:

   $$\lVert \mathbf{g}_a - \mathbf{g}_n \rVert_2 = \sqrt{14}, \qquad \lVert \mathbf{g}_a \rVert_2 = 3\sqrt{14}, \qquad \lVert \mathbf{g}_n \rVert_2 = 2\sqrt{14}$$

5. Göreli hata:

   $$\frac{\sqrt{14}}{5\sqrt{14}} = 0{,}2$$

Farkın kendisi yerine oranı kullanmak, hatayı gradyanın ölçeğinden bağımsız yapar. Gradyanlar $10^4$ mertebesindeyse $0{,}01$‘lik bir fark önemsizdir. $10^{-4}$ mertebesindeyse fark hatanın kendisidir.

Kabaca şöyle yorumla:

Sayısal gradyan yavaştır ve eğitimde kullanılmaz. Her eleman için iki fonksiyon çağrısı gerektirir. Elle yazdığın bir geri geçişi küçük bir girdi üzerinde bir kez kontrol etmek için kullanırsın.

Sayısal gradyanın kendisini Sayısal gradyan probleminde yazabilirsin.

Daha fazlası için Yoğun katmanın geri geçişi ve gradyan kontrolü dersine bak.

Sayısal gradyanı merkezi farklarla hesapla ve göreli hatayı döndür.

1. Analitik gradyanı al.
2. Bir kopya üzerinde merkezi farkları hesapla.
3. İki gradyanın göreli hatasını döndür. Payda sıfırsa 0.0 döndür.

import numpy as npdef gradient_check(f, grad_f, x: np.ndarray, h: float = 1e-5) -> float:    x = np.array(x, dtype=float)    analytic = np.asarray(grad_f(x), dtype=float)    numeric = np.zeros_like(x)    for i in np.ndindex(x.shape):        old = x[i]        x[i] = old + h        f_plus = f(x)        x[i] = old - h        f_minus = f(x)        x[i] = old        numeric[i] = (f_plus - f_minus) / (2 * h)    denominator = np.linalg.norm(analytic) + np.linalg.norm(numeric)    if denominator == 0:        return 0.0    return float(np.linalg.norm(analytic - numeric) / denominator)

Sık yapılan iki hata var:

• Sıfır paydayı unutmak: iki gradyan da sıfırsa NumPy $0/0$ için nan verir. Doğru bir gradyan hatalıymış gibi görünür.
• x tam sayı array’iyse kopyayı float yapmamak: $x_i + h$ tam sayıya kırpılır ve sayısal gradyan sıfır çıkar.