DNN_GD: Deep Neural Network from Scratch with Gradient Descent

DNN_GD, herhangi bir hazır derin öğrenme kütüphanesi (PyTorch, TensorFlow, Keras) kullanılmadan, tamamen saf NumPy ve temel matematiksel ilkelerle (first principles) sıfırdan geliştirilmiş Çok Katmanlı Derin Yapay Sinir Ağı (Multi-Layer Deep Neural Network) mimarisidir.

Ağ, İleri Yayılım (Forward Propagation), Geriye Yayılım (Backpropagation) ve Gradyan İnişi (Gradient Descent) algoritmalarını matris düzeyinde uygulayarak öğrenme gerçekleştirir.

---

🌟 Öne Çıkan Özellikler

• Saf Matematik & NumPy: Harici hiçbir derin öğrenme bağımlılığı yoktur; ağırlık matrisleri, hata türevleri ve gradyan güncellemeleri saf lineer cebir ile yürütülür.
• Sınırsız Katman Esnekliği (Arbitrary Depth): hiddennodes=[6, 12, 8, 4] gibi tek bir liste vererek istediğiniz derinlikte ve nöron sayısında çok katmanlı ağlar kurabilirsiniz.
• Girdi boyutuna göre ölçeklenmiş ilklendirme (LeCun normal): Ağırlıkların standart sapması $1/\sqrt{n_{\text{in}}}$'dir. Böylece sigmoid başlangıçta doygunluğa girmez ve gradyan erken sönmez.
• Zincir Kuralı (Chain Rule) ile Geriye Yayılım: Her katmandaki hata payı transpoz matris çarpımlarıyla geriye doğru taşınır.

---

🧠 Matematiksel Temeller ve Formülasyon

1. Ağırlık İlklendirmesi (Weight Initialization)

Her katmanın ağırlık matrisi, ortalaması 0 ve standart sapması önceki katmandaki nöron sayısına ($n_{\text{in}}$) bağlı normal dağılımdan örneklenir: $$W^{(l)} \sim \mathcal{N}\left(0,\ \sigma^2\right), \qquad \sigma = \frac{1}{\sqrt{n_{\text{in}}}}$$

2. İleri Yayılım (Forward Propagation)

Her $l$ katmanında, önceki katmanın aktivasyon vektörü ağırlık matrisiyle çarpılır ve Sigmoid fonksiyonundan geçirilir: $$z^{(l)} = W^{(l)} \cdot a^{(l-1)}$$ $$a^{(l)} = \sigma(z^{(l)}) = \frac{1}{1 + e^{-z^{(l)}}}$$

3. Aktivasyon Türevi (Sigmoid Derivative)

Sigmoid fonksiyonunun birinci türevi analitik olarak doğrudan kendi çıktısı cinsinden ifade edilir: $$\frac{d\sigma(z)}{dz} = \sigma(z) \cdot (1 - \sigma(z)) = a \cdot (1 - a)$$

4. Geriye Yayılım ve Hata Dağıtımı (Backpropagation)

• Çıkış Katmanı Hatası: $$E_{\text{output}} = y - \hat{y}$$
• Gizli Katman Hataları (Zincir Kuralı): Son katmandan geriye doğru, bir sonraki katmanın ağırlık matrisinin transpozu ile hata çarpılarak bir önceki katmanın payına düşen hata bulunur: $$E^{(l)} = (W^{(l+1)})^T \cdot E^{(l+1)}$$

5. Gradyan İnişi ile Ağırlık Güncellemesi (Gradient Descent)

Ağırlık güncelleme miktarı ($\Delta W$), öğrenme oranı ($\alpha$), katman hatası ($E^{(l)}$), katman çıktısının türevi ve önceki katmanın girdisi ($a^{(l-1)}$) kullanılarak hesaplanır: $$\Delta W^{(l)} = \alpha \cdot \left[ E^{(l)} \odot a^{(l)} \odot (1 - a^{(l)}) \right] \cdot (a^{(l-1)})^T$$ $$W^{(l)} \leftarrow W^{(l)} + \Delta W^{(l)}$$

---

📁 Proje Dosya Yapısı

DNN_GD/
│
├── dnn.py                  # neuralNetwork sınıfı (ağın çekirdeği)
├── inuse.py                # En kısa kullanım örneği
├── example.py              # Görsel grafikli, kayıp takipli kapsamlı örnek script
├── run.bat                 # Windows tek tıkla çalıştırma başlatıcısı
├── requirements.txt        # Gerekli kütüphaneler (numpy, matplotlib)
├── README.md               # Detaylı dokümantasyon ve mimari kılavuzu
├── LICENSE                 # MIT lisansı
├── tests/                  # Duman testi
│
├── assets/
│   └── dnn_architecture.jpg # 3D Yüksek çözünürlüklü yapay sinir ağı mimari şeması
│
└── data/
    └── samples.json        # Örnek çoklu sınıflandırma veri seti

---

🚀 Hızlı Başlangıç (Quickstart)

1. Bağımlılıkların Kurulması

pip install -r requirements.txt

2. Örnek Modeli Çalıştırma

Görsel kayıp eğrisi ve tahmin tablosuyla birlikte modeli çalıştırmak için:

python example.py

(Windows kullanıcıları doğrudan run.bat dosyasına çift tıklayabilir).

Konsol çıktısı örneği

Ağırlıklar sabit bir tohum olmadan başlatıldığı için sayılar her çalıştırmada değişir. Öğrenme oranı yüksek (0.6) olduğundan kayıp bazı çalıştırmalarda bir süre düştükten sonra dalgalanabilir ya da yükselebilir; birbirine benzeyen girdiler aynı tahmine karışabilir. Aşağıdaki çıktı tek bir çalıştırmadır:

======================================================================
       DNN + GD: Deep Neural Network Trained by Gradient Descent
                 Created from Scratch by İlhan Koçaslan
======================================================================

[*] Network Architecture:
    - Input Features:   5 neurons
    - Hidden Layers:    [6, 8, 4] (3 layers)
    - Output Targets:   3 neurons
    - Total Layers:     [5, 6, 8, 4, 3]
    - Learning Rate:    0.6
    - Training Samples: 6

[+] Training for 800 epochs using Gradient Descent & Backpropagation...
    Epoch [   1/ 800] [-------------------------] - MSE Loss: 0.297015
    Epoch [ 200/ 800] [======-------------------] - MSE Loss: 0.026880
    Epoch [ 400/ 800] [============-------------] - MSE Loss: 0.057155
    Epoch [ 800/ 800] [=========================] - MSE Loss: 0.056170

[OK] Training completed successfully!

======================================================================
                         TEST PREDICTIONS
======================================================================
Sample   Input Pattern          Expected Target    Predicted Output    
----------------------------------------------------------------------
#1       [0, 0, 0, 0, 1]        [0, 1, 0]          [0.017, 0.993, 0.037]
#2       [0, 0, 1, 0, 0]        [1, 0, 0]          [0.996, 0.031, 0.034]
#3       [0, 1, 0, 1, 0]        [0, 0, 1]          [0.519, 0.498, 0.995]
#4       [1, 0, 0, 0, 1]        [0, 1, 1]          [0.003, 0.973, 0.956]
======================================================================

---

📖 neuralNetwork Sınıfı Kullanım Kılavuzu

dnn.py dosyasını kendi projenizde şu şekilde içe aktararak kullanabilirsiniz:

import dnn

# 1. Modeli tanımla (İstediğiniz derinlikte katman belirtebilirsiniz)
nn = dnn.neuralNetwork(
    inputnodes=5,               # Giriş özellik sayısı
    hiddennodes=[8, 12, 6],     # Gizli katmanların nöron listesi (3 gizli katman)
    outputnodes=3,              # Çıkış nöron sayısı
    learningrate=0.5            # Öğrenme katsayısı (alpha)
)

# 2. Modeli eğit
inputs = [[0, 0, 0, 0, 1], [1, 1, 1, 1, 0]]
targets = [[0, 1, 0], [1, 1, 1]]

for epoch in range(500):
    nn.train(inputs_list=inputs, targets_list=targets)

# 3. Yeni veri üzerinde tahmin: query sonucu ekrana yazar (değer döndürmez)
nn.query([[0, 0, 0, 0, 1]])

---

⚔️ Karşılaştırma: DNN_GD vs DNN_PSO

Aynı yazarın iki farklı eğitim yaklaşımının kıyaslaması:

Karşılaştırma Kriteri	DNN_GD (Bu Proje)	DNN_PSO
Optimizasyon Yöntemi	Geriye Yayılım (Backpropagation)	Parçacık Sürü Optimizasyonu (PSO)
Ağırlık Güncellemesi	Gradyan İnişi ($\nabla Loss$)	Sürü En İyisi ($G_{\text{best}}, P_{\text{best}}$)
Türev İhtiyacı	Zorunlu (Zincir Kuralı)	Türevsiz (Derivative-Free)
Hesaplama Maliyeti	Adım başına bir ileri ve bir geri geçiş	Adım başına parçacık sayısı kadar ileri geçiş
Yerel Minimum	Takılabilir (yerel çukurlar, eyer noktaları)	Sürü daha geniş arar, ama erken yakınsama riski de vardır
Uygun Olduğu Durum	Türevlenebilir, çok parametreli ağlar	Türevsiz ya da küçük ağlar, ayrık/gürültülü amaçlar

---

👨‍💻 Yazar

• İlhan Koçaslan — GitHub: @Proaiml

🧪 Test

pip install pytest
python -m pytest tests -q

Test, ağın kurulduğunu, eğitimin ağırlıkları değiştirdiğini ve sorgunun çalıştığını denetler; bir saniyeden kısa sürer.