Yapay Sinir Ağlarının
Dili

YSA'nın Tarihi = Bu Dönemin Planı

Biyolojik nörondan esinlenen 80 yıllık bir hikâye — her dönüm noktası bir hafta. Hepsi aynı dili konuşuyor: bu haftanın araçları.

Bu hafta: tensör (veri) ve lineer cebir (hesap) — NumPy/PyTorch ile uygulamalı. Türev (değişim) Hafta 3'te, öğrenme kurallarıyla birlikte; otomatik türev (autograd) 7. haftada.

Her Ağ, Aynı Üç Şey

Bu hafta ilk ikisini elle anlayıp koda dökeceğiz; türev Hafta 3'te. Dersin geri kalanı hep bu üç dilin cümleleri.

Tensör: Yapıtaşı & Oluşturma

import torch
x = torch.arange(6)          # [0, 1, 2, 3, 4, 5]

X = x.reshape(2, 3)          # [[0, 1, 2],
                             #  [3, 4, 5]]
X.shape                      # (2, 3)  ·  X.numel() → 6
torch.zeros(2, 3)            # sıfır matrisi (torch.ones / torch.randn)

shape = boyutlar, numel = eleman sayısı. NumPy'da birebir: np.arange, reshape.

Eriş, Dilimle, Ata

X = torch.arange(12).reshape(3, 4)
#  [[ 0,  1,  2,  3],
#   [ 4,  5,  6,  7],
#   [ 8,  9, 10, 11]]
X[-1]      # [8, 9, 10, 11]   son satır
X[:, 1]    # [1, 5, 9]        2. sütun
X[1, 2]    # 6                tek eleman

Negatif indeks sondan sayar: X[-1] son satır, X[:, -1] son sütun.

Eleman-Eleman & Birleştirme

x = torch.tensor([1., 2, 4, 8])
y = torch.tensor([2., 2, 2, 2])
x + y     # [ 3.,  4.,  6., 10.]
x * y     # [ 2.,  4.,  8., 16.]
x ** y    # [ 1.,  4., 16., 64.]
torch.exp(x)         # [2.7, 7.4, 54.6, 2981.]
torch.cat((x, y))    # [1,2,4,8, 2,2,2,2]

Kural: döngü değil, tüm tensör üstünde tek işlem düşün — birazdan bunun hız demek olduğunu ölçeceğiz.

Farklı Şekiller Nasıl Toplanır?

a = torch.tensor([[1], [2], [3]])   # 3×1
b = torch.tensor([[10, 20]])        # 1×2
a + b        # → [[11, 21], [12, 22], [13, 23]]  (3×2, döngüsüz!)

Boyut 1 olan eksen otomatik tekrarlanır. Bias eklerken (X @ W + b) tam bunu kullanacağız.

Yerinde İşlem & NumPy ↔ Torch

X, Y = torch.ones(3, 4), torch.ones(3, 4)
before = id(Y)
Y = Y + X;   id(Y) == before   # False → yeni bellek!

Z = torch.zeros_like(Y);  Z[:] = X + Y   # yerinde yaz
X += Y                                    # yerinde (bellek dostu)

A = X.numpy()            # Torch → NumPy
B = torch.from_numpy(A)  # NumPy → Torch

a = torch.tensor([3.5])
a.item()                 # → 3.5  (1-elemanlı → sayı)

Büyük tensörlerde yerinde işlem (+=, [:]) gereksiz kopya üretmez. .numpy() / from_numpy kopyalamaz — bellek paylaşılır: birini değiştirirsen öteki de değişir!

Ham Veri → Temiz Tablo

import pandas as pd
data = pd.read_csv('ev.csv')   # 5 ev × 4 sütun (soldaki tablo)
data.isna().sum()   # sütun başına eksik: Oda 1, Alan_m2 1, Isitma 1

X = data.iloc[:, :3]   # girdiler: ilk 3 sütun (Oda, Alan_m2, Isitma)
y = data.iloc[:, 3]    # hedef: 4. sütun (Fiyat)

Üç sorun var: ① sayısal eksik (Oda, Alan_m2) · ② kategorik eksik (Isitma) · ③ metin değerler (Kombi, Soba). Model yalnız sayı anlar → önce temizlemeliyiz.

Eksiği Doldur, Tensöre Çevir

X = X.fillna({'Isitma': 'Bilinmiyor'})  # ② kategorik eksik → yeni kategori
X = pd.get_dummies(X, dtype=float)       # ③ metin → 0/1 sütunlar (one-hot)
X = X.fillna(X.mean())                   # ① sayısal eksik → sütun ortalaması
X = torch.tensor(X.values, dtype=torch.float32)  # X.shape → (5, 5)

Ön işleme = veriyi eksiksiz sayısal tensöre çevirmek. (Not: ortalamayı tüm veriden aldık; 8. haftada neden yalnız eğitim verisinden alınması gerektiğini göreceğiz.)

Skaler → Vektör → Matris

🔈 okunuş: ∈ “elemanıdır”: x ∈ ℝ → x bir reel sayıdır·ℝ “reel sayılar”: ℝⁿ: n elemanlı reel vektör

x = torch.tensor(3.0)               # skaler
v = torch.arange(4)                 # [0, 1, 2, 3]
A = torch.arange(6).reshape(3, 2)   # [[0,1],[2,3],[4,5]]

A.T                                 # [[0,2,4],[1,3,5]]  (2×3)

Bir örnek genelde bir vektör; bir veri kümesi (batch) bir matris; bir grup görüntü bir 4B tensör.

Hadamard Çarpımı (eleman-eleman)

🔈 okunuş: ⊙ “hadamard”: eleman-eleman çarpım·A_ij “A i j”: i. satır, j. sütun

A = torch.tensor([[1., 2], [3, 4]])
B = torch.tensor([[2., 0], [1, 3]])
A * B        # [[2, 0], [3, 12]]  Hadamard
A + 2        # her elemana skaler ekle
A * 2        # her elemanı ölçekle

Topla, Ortala, Eksen Seç

🔈 okunuş: Σ “sigma (büyük)”: hepsini topla·x̄ “x bar”: ortalama

A = torch.arange(1., 7).reshape(2, 3)  # [[1,2,3],[4,5,6]]  (float!)
A.sum(), A.mean()              # 21., 3.5  (mean int'te hata verir)
A.sum(axis=0)                  # [5, 7, 9]   (sütunlar)
A.sum(axis=1)                  # [6, 15]     (satırlar)
A.sum(axis=1, keepdims=True)   # [[6],[15]]  boyut korunur

Normalizasyonda sık kalıp: A / A.sum(axis=1, keepdims=True) — keepdims sayesinde broadcast çalışır.

İndirgeme — Somut Sayılar

axis=0 → sütun toplamı, axis=1 → satır toplamı · ayrıca sum()=21, mean()=3.5.

Nokta Çarpım: Bir Nöronun Çekirdeği

🔈 okunuş: xᵀ “x transpoz”: sütun vektörü satıra çevir

x = torch.tensor([1., 2., 3.])
w = torch.tensor([0.5, -1., 2.])

torch.dot(w, x)          # 0.5 - 2 + 6 = 4.5
torch.sum(w * x)         # aynı sonuç

Tek nöron bir nokta çarpım; bir katman bunun yüzlercesi → matris çarpımı.

Katman = Matris Çarpımı

A = torch.tensor([[1., 2], [3, 4]])
x = torch.tensor([1., 1])
torch.mv(A, x)   # matris×vektör → [3., 7.]
torch.mm(A, A)   # matris×matris → [[7,10],[15,22]]
A @ A            # aynısı (NumPy'da: A @ B)

İyi haber: matris çarpımı utanç verecek kadar paralel — önce elle hesaplayalım, sonra hızını ölçelim.

Matris Çarpımı — Adım Adım

Her hücre = soldaki satır · sağdaki sütun (nokta çarpım). Aynı mantık matris-vektörde de geçerli.

Aynı Hesap, Farklı Hız

256×256 matris çarpımı = 2·256³ ≈ 33,6 milyon işlem · sonuçlar birebir aynı

Gerçek Veri: MNIST'i Bir Katmandan Geçir

Her rakam 28×28 = 784 piksel → reshape(-1) ile bir satır. 60.000 görüntü: X: (60000, 784) · W: (784, 512) → Y = X @ W ≈ 48 milyar işlem

Y = X @ W                  # CPU
Xg = X.to('cuda')          # tek satır fark
Wg = W.to('cuda')
Yg = Xg @ Wg               # aynı kod, GPU'da

Bir Vektörün Büyüklüğü

u = torch.tensor([3., -4.])
torch.linalg.norm(u)        # 5.  L2 (Öklid uzunluğu)
u.abs().sum()               # 7.  L1 (mutlak değer toplamı)
torch.linalg.norm(torch.ones(4, 9))   # 6.  Frobenius

YSA'nın Dilini Öğrendik

Sonraki hafta: bu araçlarla ilk yapay nöronu kuracak ve aktivasyon fonksiyonlarını öğreneceğiz; türev Hafta 3'te, autograd + geri yayılım 7. haftada.

Dili Kendin Konuş

İpucu: her adımı önce elle hesapla, sonra kodda doğrula.