Sinir ağı visualizer: veri nasıl akar?

2026 · 12 dakika okuma

Sinir ağları hakkında her yerde "insan beyninden ilham alındı" yazıyor. Ama gerçekte ne oluyor? Veri bir uçtan giriyor, öbür uçtan çıkıyor — arada ne var?

Cevap: matris çarpımları ve aktivasyon fonksiyonları. Demoya bak, sonra anlat.

Önce dene

Katman boyutlarını ayarla. Sinyal gönder, verinin ağdan nasıl aktığını izle. Sarı parlayan nöronlar aktif, bağlantı kalınlığı ağırlığı, rengi işareti temsil ediyor.

Nöron ne yapar?

Her nöron üç şey yapar: girdi toplar, ağırlıklarla çarpar, aktivasyon uygular.

# Tek bir nöronun hesabı
def neuron(inputs, weights, bias):
    # 1. Ağırlıklı toplam (dot product)
    z = sum(x * w for x, w in zip(inputs, weights)) + bias
    
    # 2. Aktivasyon fonksiyonu uygula
    output = relu(z)   # veya sigmoid(z)
    return output

def relu(z):
    return max(0, z)   # negatifse 0, pozitifse kendisi

def sigmoid(z):
    return 1 / (1 + exp(-z))  # 0 ile 1 arasına sıkıştır

Katmanlar ve ileri besleme

Bir katmanın tüm nöronları hesaplandıktan sonra sonraki katmana geçilir. Buna ileri besleme (forward pass) denir.

import numpy as np

def forward_pass(X, weights, biases):
    """
    X: girdi verisi (n_samples, n_features)
    weights: her katman için ağırlık matrisi listesi
    biases: her katman için bias vektörü listesi
    """
    activations = X
    
    for W, b in zip(weights[:-1], biases[:-1]):
        z = activations @ W + b     # matris çarpımı
        activations = relu(z)       # gizli katmanlarda ReLU
    
    # Son katman: sınıflandırma için softmax
    z = activations @ weights[-1] + biases[-1]
    output = softmax(z)
    
    return output

def relu(z):
    return np.maximum(0, z)

def softmax(z):
    e = np.exp(z - z.max(axis=1, keepdims=True))
    return e / e.sum(axis=1, keepdims=True)

Ağırlıklar nasıl öğrenir?

Demoda ağırlıklar rastgele. Gerçek hayatta geri yayılım (backpropagation)ile öğrenilir. Hata hesaplanır, gradient descent ile ağırlıklar güncellenir. Binlerce kez tekrarlanır.

GPT gibi modellerde milyarlarca ağırlık var. Ama her ağırlık aynı prensibi takip eder: hatayı azaltmak için gradient yönünde biraz güncelle. Gradient descent demosumuzu hatırlıyor musun?

import torch
import torch.nn as nn

# PyTorch ile basit sinir ağı
class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(input_size, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, hidden_size),
            nn.ReLU(),
            nn.Linear(hidden_size, output_size),
            nn.Sigmoid()
        )
    
    def forward(self, x):
        return self.network(x)

# Model oluştur
model = SimpleNN(input_size=3, hidden_size=4, output_size=2)

# Eğit
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
criterion = nn.BCELoss()

for epoch in range(100):
    optimizer.zero_grad()
    output = model(X_train)
    loss = criterion(output, y_train)
    loss.backward()    # gradientleri hesapla
    optimizer.step()   # ağırlıkları güncelle

Aktivasyon fonksiyonları neden gerekli?

Aktivasyon fonksiyonu olmasa tüm katmanlar tek bir doğrusal dönüşüme indirgenir. Ne kadar katman ekleersen ekle, model doğrusal ilişkileri ancak öğrenebilir. ReLU, Sigmoid, Tanh gibi fonksiyonlar doğrusal olmayan ilişkileri öğrenmesi için gereklidir.

• ReLU: Gizli katmanlarda en yaygın. Hızlı, gradient kaybolma sorununu azaltır.
• Sigmoid: İkili sınıflandırma çıktısı için. 0-1 arası değer üretir.
• Softmax: Çok sınıflı sınıflandırma için. Tüm çıktılar toplamı 1'e eşit.
• Tanh: -1 ile 1 arasında. RNN'lerde yaygın.

Sıradaki yazıda Central Limit Theorem: farklı dağılımlardan örneklem çek, ortalamaların neden normale yakınsadığını izle.