👩‍💻 Yapay Sinir Ağlarıyla ilgili Pyhton Kod Parçaları

📚 ML'de Genel Kod Parçaları

💥 Sigmoid Fonksiyonu

➗ Formül
👩‍💻 Kod
sigmoid(x)=11+exp(x)sigmoid(x)=\frac{1}{1+exp(-x)}
1
def sigmoid(x):
2
"""
3
Argümanlar:
4
x -- Skaler, dizi veya matris
5
6
Dönüş değeri:
7
result -- sigmoid(x)
8
"""
9
10
result = 1 /( 1 + np.exp(-x) )
11
12
return result
Copied!

🚀 Sigmoid Gradient

👩‍🏫 Açıklama
➗ Formül
👩‍💻 Kod
backpropagation kullanarak loss fonksiyonlarını optimize etmek için gradient'leri hesaplayan fonksiyon
1
def sigmoid_derivative(x):
2
"""
3
Sigmoid fonksiyonunun gradient'ını (eğim veya türev olarak da adlandırılır), x girdisine göre hesaplar
4
Argümanlar:
5
x -- scaler veya Numpy dizisi
6
7
Dönüş değeri:
8
ds -- Hesaplanan gradient.
9
"""
10
11
s = 1 / (1 + np.exp(-x))
12
ds = s * (1 - s)
13
14
return ds
Copied!

👩‍🔧 Dizileri (Veya resimleri) Yeniden Şekillendirme

👩‍💻 Kod
1
def arr2vec(arr, target):
2
"""
3
Argümanlar:
4
image -- (length, height, depth) boyutunda bir Numpy dizisi
5
6
Dönüş değeri:
7
v -- (length*height*depth, 1) boyutunda bir vektör
8
"""
9
10
v = image.reshape(image.shape[0] * image.shape[1] * image.shape[2], 1)
11
12
return v
Copied!

💥 Satırları Normalize Etme

👩‍🏫 Açıklama
➗ Formül
👩‍💻 Kod
X'in her satır vektörünü normuna göre bölme.
Normalization(x)=xxNormalization(x)=\frac{x}{||x||}
1
def normalizeRows(x):
2
"""
3
Argümanlar:
4
x -- (n, m) boyutunda bir Numpy dizisi
5
6
Dönüş değeri:
7
x -- Normalize edilmiş (satıra göre) Numpy matrisi.
8
"""
9
10
# Normları hesaplama
11
x_norm = np.linalg.norm(x, axis=1, keepdims=True)
12
13
# x'i normuna bölme
14
x = x / x_norm
15
16
return x
Copied!

🎨 Softmax Fonksiyonu

👩‍🏫 Açıklama
➗ Formül
👩‍💻 Kod
Algoritmanın iki veya daha fazla sınıfı sınıflandırması gerektiğinde kullanılan normalleştirme fonksiyonu
Softmax(xi)=exp(xi)jexp(xj)Softmax(x_i)=\frac{exp(x_i)}{\sum_{j}exp(x_j)}
1
def softmax(x):
2
"""X girişinin her satırı için softmax değerini hesaplar.
3
4
Argümanlar:
5
x -- (n,m) boyutunda bir matris
6
7
Dönüş değeri:
8
s -- (X, m) şeklindeki softmax x değerine eşit bir matris matrisi
9
"""
10
11
# Exp () element-wise komutunu x'e uygulama
12
x_exp = np.exp(x)
13
14
# X_exp'nin her satırını toplayan bir vektör x_sum oluşturma
15
x_sum = np.sum(x_exp, axis=1, keepdims=True)
16
17
# Softmax (x)'in x_exp'i x_sum ile bölerek hesaplanması.
18
# numpy broadcasting otomatik olarak kullanılacak
19
s = x_exp / x_sum
20
21
return s
Copied!

🤸‍♀️ L1 Loss Fonksiyonu

👩‍🏫 Açıklama
➗ Formüla
👩‍💻 Kod
Kayıp, modelin performansını değerlendirmek için kullanılır. Kayıp ne kadar büyükse, tahminlerin (ŷ) gerçek değerlerden (y) o kadar farklı olmasıdır. Derin öğrenmede, modeli eğitmek ve maliyeti en aza indirmek için Gradient Descent gibi optimizasyon algoritmaları kullanıyoruz.
L1(y^,y)=i=0m(y(i)y^(i))L_1(\hat{y},y)=\sum_{i=0}^{m}(|y^{(i)}-\hat{y}^{(i)}|)
1
def L1(yhat, y):
2
"""
3
Argümanlar:
4
yhat -- m boyutunda bir vektör (tahmin edilen etiketler)
5
y -- m boyutunda bir vektör (doğru etiketler)
6
7
Dönüş değeri:
8
loss -- yanda tanımlanan L1 fonksiyonunun değeri
9
"""
10
11
loss = np.sum(np.abs(y - yhat))
12
13
return loss
Copied!

🤸‍♂️ L2 Loss Fonksiyonu

👩‍🏫 Açıklama
➗ Formül
👩‍💻 Kod
Kayıp, modelin performansını değerlendirmek için kullanılır. Kayıp ne kadar büyükse, tahminlerin (ŷ) gerçek değerlerden (y) o kadar farklı olmasıdır. Derin öğrenmede, modeli eğitmek ve maliyeti en aza indirmek için Gradient Descent gibi optimizasyon algoritmaları kullanıyoruz.
L2(y^,y)=i=0m(y(i)y^(i))2L_2(\hat{y},y)=\sum_{i=0}^{m}(y^{(i)}-\hat{y}^{(i)})^2
1
def L2(yhat, y):
2
"""
3
Argümanlar:
4
yhat -- m boyutunda bir vektör(tahmin edilen etiketler)
5
y -- m boyutunda bir vektör(doğru etiketler)
6
7
Dönüş değeri:
8
loss -- yanda tanımlanan L1 fonksiyonunun değeri
9
"""
10
11
loss = np.sum((y - yhat) ** 2)
12
13
return loss
Copied!

🏃‍♀️ Yayılma Fonksiyonnu Propagation Function

👩‍🏫 Açıklama
➗ Formül
👩‍💻 Kod
Parametreleri öğrenmek için "ileri" ve "geri" yayılma adımlarını yapmak.
Jw=1mX(AY)T\frac{\partial J}{\partial w}=\frac{1}{m}X(A-Y)^T
Jb=1mi=1m(a(i)y(i))\frac{\partial J}{\partial b}=\frac{1}{m}\sum_{i=1}^{m}(a^{(i)}-y^{(i)})
1
def propagate(w, b, X, Y):
2
"""
3
Cost fonksiyonunu ve gradient'leri hasaplamanın emplemantasyonu
4
5
Argümanlar:
6
w -- ağırlıklar, (num_px * num_px * 3, 1) boyutunda bir Numpy dizisi
7
b -- önyargı (bias), bir skalerdir
8
X -- (num_px * num_px * 3, örnek sayısı) boyutunda veriler
9
Y -- doğru etiket vektörü (kedi değilse 0, kediyse 1), (1, örnek sayısı) boyutunda
10
11
Dönüş değeri:
12
cost -- lojistik regresyon için negatif log olabilirlik cost'u
13
dw -- w'ye göre kaybın gradyanı, bu nedenle w ile aynı boyutta
14
db -- b'ye göre kaybın gradyanı, bu nedenle b ile aynı boyutta
15
16
"""
17
18
m = X.shape[1]
19
20
# İLERİ YAYILMA (X’DEN MALİYETE)
21
22
# aktivasyonu hesaplama
23
A = sigmoid( np.dot(w.T, X) + b )
24
25
# cost'u hesaplama
26
cost = - np.sum( Y * np.log(A) + (1-Y) * np.log(1 - A) ) / m
27
28
# GERİ YAYILMA (GRAD'ı BULMAK İÇİN)
29
30
dw = (np.dot(X,(A-Y).T))/m
31
db = np.sum(A-Y)/m
32
33
grads = {"dw": dw,
34
"db": db}
35
36
return grads, cost
Copied!

💫 Gradyan İnişi Gradient Descent (Optimizasyon)

👩‍🏫 Açıklama
➗ Formül
👩‍💻 Kod
Amaç, maliyet fonksiyonunu J'yi en aza indirerek ω ve b'yi öğrenmektir.
w=wαdww=w-\alpha dw
α öğrenme hızıdır learning rate
1
def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
2
"""
3
gradient descent algoritması çalıştırarak w ve b'yi optimize eder
4
5
Argümanlar:
6
w -- ağırlıklar, (num_px * num_px * 3, 1) boyutunda bir Numpy dizisi
7
b -- önyargı (bias), bir skalerdir
8
X -- (num_px * num_px * 3, kayıt sayısı) boyutunda veriler
9
Y -- doğru etiket vektörü (kedi değilse 0, kediyse 1), (1, örnek sayısı) boyutunda
10
num_iterations -- optimizasyon döngüsünün iterasyon sayısı
11
learning_rate -- gradient descent'in öğrenme hızı
12
print_cost -- True ise kaybı her 100 adım yazdırır
13
14
Dönüş değeri:
15
params -- ağırlıkları ve bias'ı içeren bir dictionary
16
grads -- cost fonksiyonuna göre ağırlıkları ve bias'ı içeren bir dictionary
17
costs -- optimizasyon esnasında bütün kayıp değerlerini içeren bir list, öğrenme eğrisini çizerken kullanılacak
18
"""
19
20
costs = []
21
22
for i in range(num_iterations):
23
24
25
# Cost ve gradient'ı hesaplama
26
grads, cost = propagate(w, b, X, Y)
27
28
# türevleri grad'lardan elde etme
29
dw = grads["dw"]
30
db = grads["db"]
31
32
# kuralı güncelleme
33
w = w - learning_rate*dw
34
b = b - learning_rate*db
35
36
# cost'ları kaydetme
37
if i % 100 == 0:
38
costs.append(cost)
39
40
# kaybı her 100 iterasyonda yazdırır (opsiyonel)
41
if print_cost and i % 100 == 0:
42
print ("Cost after iteration %i: %f" %(i, cost))
43
44
params = {"w": w,
45
"b": b}
46
47
grads = {"dw": dw,
48
"db": db}
49
50
return params, grads, costs
Copied!

🕸 Basit Bir NN Temel Kod Parçları

2 katmanlı ağın fonksiyonları
Giriş katmanı, 1 gizli katman ve çıkış katmanı

🚀 Parametreleri Başlatma Initialization

👩‍🏫 Açıklama
👩‍🏫 Kod
W'leri ve b'leri başlatma konusunda, W'ler Simetriği kırma adına rastgele değerlerle başlatmalıyız, b'yi ise sıfır olarak başlatabiliriz.
1
def initialize_parameters(n_x, n_h, n_y):
2
"""
3
Argümanlar:
4
n_x -- giriş katmanının boyutu
5
n_h -- gizli katmanın boyutu
6
n_y -- çıkış katmanının boyutu
7
8
Dönüş değeri:
9
params -- parametreleri içeren bir:
10
W1 -- (n_h, n_x) boyutundaki ağırlıklar matrisi
11
b1 -- (n_h, 1) boyutundaki bias vektörü
12
W2 -- (n_y, n_h) boyutundaki ağırlıklar matrisi
13
b2 -- (n_y, 1) boyutundaki bias vektörü
14
"""
15
# değerleri küçültmek için 0.01 ile çarpma
16
W1 = np.random.randn(n_h,n_x) * 0.01
17
b1 = np.zeros((n_h,1))
18
W2 = np.random.randn(n_y,n_h) * 0.01
19
b2 = np.zeros((n_y,1))
20
21
parameters = {"W1": W1,
22
"b1": b1,
23
"W2": W2,
24
"b2": b2}
25
26
return parameters
Copied!

⏩ İleri Yayılma

👩‍🏫 Açıklama
👩‍💻 Kod
Her katman giriş verilerini alır, aktivasyon fonksiyonuna göre işler ve sonraki katmana geçirir
1
def forward_propagation(X, parameters):
2
"""
3
Argümanlar:
4
X -- (n_x, m) boyutundaki giriş verileri
5
parameters -- parametreleri içeren dictionary (başlatma fonksiyonunun çıkış değeri)
6
7
Dönüş değeri:
8
A2 -- ikinci aktivasyonun sigmoid çıkışı
9
cache -- "Z1", "A1", "Z2" and "A2" değerlerini içeren dictionary
10
"""
11
12
# parameters'den parametreleri elde etme
13
W1 = parameters['W1']
14
b1 = parameters['b1']
15
W2 = parameters['W2']
16
b2 = parameters['b2']
17
18
Z1 = np.dot(W1, X) + b1
19
A1 = np.tanh(Z1)
20
Z2 = np.dot(W2, A1) + b2
21
A2 = sigmoid(Z2)
22
23
cache = {"Z1": Z1,
24
"A1": A1,
25
"Z2": Z2,
26
"A2": A2}
27
28
return A2, cache
Copied!

🚩 Maliyet Fonksiyonu Cost

.👩‍🏫 Açıklama
➗ Formül
👩‍💻 Kod
Çıkış katmanı nedeniyle ayarlanan tüm eğitimin loss fonksiyonlarının ortalaması
J=1mi=1m(y(i)log(a[2](i))+(1y(i)log(1a[2](i))))J=-\frac{1}{m}\sum_{i=1}^{m}(y^{(i)}log(a^{[2](i)}) + (1-y^{(i)}log(1-a^{[2](i)})))
1
def compute_cost(A2, Y):
2
"""
3
Formülde verilen cross-entropy maliyetini hesaplar
4
5
Argümanlar:
6
A2 -- ikinci aktivasyonun sigmoid çıkışı, (1, örnek sayısı) boyutunda
7
Y -- "true" etiket vektörü (1, örnek sayısı) boyutunda
8
9
Dönüş değeri:
10
cost -- formülde verilen cross-entropy maliyeti
11
12
"""
13
14
# örnek sayısı
15
m = Y.shape[1]
16
17
# cross-entropy maliyetini hesaplama
18
logprobs = np.multiply(np.log(A2), Y) + (1 - Y) * np.log(1 - A2)
19
cost = - np.sum(logprobs) / m
20
cost = float(np.squeeze(cost))
21
22
return cost
Copied!

⏪ Geri Yayılma

👩‍🏫 Açıklama
➗ Formül
👩‍💻 Kod
Ağırlıkların uygun şekilde ayarlanması daha düşük hata oranlarını garanti eder ve modellemeyi genellemesini artırarak güvenilir kılar.
1
def backward_propagation(parameters, cache, X, Y):
2
"""
3
Daha önce verilen talimatları kullanarak geriye doğru yayılımı uygular
4
5
Argümanlar:
6
parameters -- parametrelerimizi içeren dictionary
7
cache -- "Z1", "A1", "Z2" and "A2" değerlerini içeren dictionary
8
X -- (2, örnek sayısı) boyutundaki giriş verileri
9
Y -- "true" etiket vektörü, (1, örnek sayısı) boyutunda
10
11
Dönüş değeri:
12
grads -- farklı parametrelere göre gradyanları içeren dictionary
13
"""
14
m = X.shape[1]
15
16
# parameters'dan W1 ve W2'yi elde etme
17
W1 = parameters['W1']
18
W2 = parameters['W2']
19
20
# cache'den A1 ve A2'yi elde etme
21
A1 = cache['A1']
22
A2 = cache['A2']
23
24
# Geri yayılma: calculating dW1, db1, dW2, db2 hesaplama
25
dZ2 = A2 - Y
26
dW2 = np.dot(dZ2, A1.T) / m
27
db2 = np.sum(dZ2, axis = 1, keepdims = True) / m
28
dZ1 = np.dot(W2.T, dZ2) * (1 - A1 ** 2)
29
dW1 = np.dot(dZ1, X.T) / m
30
db1 = np.sum(dZ1, axis = 1, keepdims = True) / m
31
32
grads = {"dW1": dW1,
33
"db1": db1,
34
"dW2": dW2,
35
"db2": db2}
36
37
return grads
Copied!

🔃 Parametreleri Güncelleme

👩‍🏫 Açıklama
➗ Formül
👩‍💻 Kod
Gradient descent'i tamamlamak için öğrenme hızına bağlı olarak parametrelerin güncellenmesi
θ:=θαJθ\theta := \theta - \alpha \frac{\partial J}{\partial \theta}
1
def update_parameters(parameters, grads, learning_rate = 1.2):
2
"""
3
Daha önce verilen gradient descent güncelleme kuralını kullanarak parametreleri günceller
4
5
Argümanlar:
6
parameters -- parametrelerimizi içeren dictionary
7
grads -- gradyanlarımızı içeren dictionary
8
9
Dönüş değeri:
10
parameters -- güncellenmiş parametreleri içeren dictionary
11
"""
12
# "parameters"'dan parametreleri elde etme
13
W1 = parameters['W1']
14
b1 = parameters['b1']
15
W2 = parameters['W2']
16
b2 = parameters['b2']
17
18
# "grads"dan gradyanları elde etme
19
dW1 = grads['dW1']
20
db1 = grads['db1']
21
dW2 = grads['dW2']
22
db2 = grads['db2']
23
24
# Kuralı her parametre için güncelleme
25
W1 = W1 - learning_rate * dW1
26
b1 = b1 - learning_rate * db1
27
W2 = W2 - learning_rate * dW2
28
b2 = b2 - learning_rate * db2
29
30
parameters = {"W1": W1,
31
"b1": b1,
32
"W2": W2,
33
"b2": b2}
34
35
return parameters
Copied!

🌞 Yazının Aslı