🎈 Açıklama

• 🤝 Türkçe içeriğine katkıda bulunmak adına İngilizce olan DeepLearningNotes 🦋 projemin çevirisidir

• 🐛 Dil hataları veya düzgün çevrilmemiş cümleler bulduğunuzda Pull Request veya Issue açarak bana bildirmeniz hoş olur 😇

📑 İçerikler

💉 Eklentiler

🙌 Söz

Öğrenme algoritmanızın iki ana bilgi kaynağı vardır; bir tanesi veri, diğeri de elle müdahele ederek yaptığımız dokunuşlar 🤔🚀

⭐ Lütfen..

• ✨ Pull Request açarak içeriği iyileştirmeme ve artırmama yardımcı olun

• 👓 Bana bir mail atarak veya issue açarak önerilerinizi söyleyin

🤝 İletişim

Bana mail atarak veya LinkedIn üzerinden ulaşarak benimle iletişime geçebilirsiniz, Asmaa 🦋

Aşağıda verilen veri seti için:

Bizim amacımız:

📚 Temel Kavramlar ve Notasyonlar

Başka bir deyişle: Maliyet Fonksiyonu w ve b veri seti için ne kadar iyi olduklarını ölçer. Ona dayanarak, en iyi w ve b değerleri, 𝙹(w, b)'ı mümkün olduğunca küçülten değerlerdir

📉 Gradyan İnişi

Gradyan inişi, türevlenebilir bir fonksiyonun yerel minimumunu bulmak için birinci dereceden yinelemeli bir optimizasyon algoritmasıdır. Buradaki ana fikir, mevcut noktada fonksiyonun gradyanının (veya yaklaşık gradyanının) zıt yönünde tekrarlanan adımlar atmaktır, çünkü bu en dik iniş yönüdür. Diğer taraftan, gradyan yönünde adım atmak, bu fonksiyonun yerel bir maksimumuna yol açacaktır; bu prosedür de gradyan yükselişi olarak bilinir.

Genel Formül:

α (alpha) Öğrenme Hızı'dir (Learning Rate)

🥽 Öğrenme Hızı (Learning Rate)

Model ağırlıkları her güncellendiğinde karşılık gelen tahmini hata nedeniyle her Gradyan İnişi tekrarının adımının boyutunu belirleyen pozitif bir skalardır, bu nedenle bir sinir ağı modelinin bir problemi ne kadar hızlı veya yavaş öğrendiğini kontrol eder.

🎀 İyi Öğrenme Hızı

💢 Kötü Öğrenme Hızı

🌞 Yazının Aslı

• Burada 🐾

🧐 Referanslar

• Introduction to Artificial Neural Networks (ANN)

• More on Learning Rate

• Gradient descent - Wikipedia

Yapay sinir ağı kavramlarını teorik detayları ile barındırır

🔎 Tanım

Bir sinir ağı, insan beyni gibi kendini modelleyen bir makine öğrenmesi türüdür. Bu, bir algoritma ile bilgisayarın yeni veriler eklenerek öğrenmesini sağlayan yapay bir sinir ağı oluşturur.

Yapay sinir ağları derin öğrenme olarak adlandırılan şeyi gerçekleştirebilir. Beynin temel birimi nöron iken, yapay bir sinir ağının temel yapı taşı basit sinyal işlemeyi gerçekleştiren bir algılayıcıdır ve bunlar daha sonra büyük bir ağa bağlanır.

📑 NN Türleri

Birçok sinir ağı türü vardır, uygun türü seçmek, çözmeye çalıştığımız soruna bağlıdır, örneğin

🎨 Denetimli Öğrenmede Veri Türleri

• 🚧 Yapılandırılmış Veriler

  • Tablolar

  • Giriş alanlarımız ve çıktı alanımız var

• 🤹‍♂️ Yapılandırılmamış Veriler

  • Görüntüler, sesler ve metinler gibi

  • Modelimizi oluşturmak için özellik çıkarma algoritmaları kullanmamız gerekiyor

🌞 Yazının Aslı

• Burada 🐾

🧐 Referanslar

• Introduction to Artificial Neural Networks (ANN)

🧐 Proje Hakkında

• 🕸 Düz Yapay Sinir Ağları, Evrişimli Yapay Sinir Ağları ve Tekrarlayan Yapay Sinir Ağlarının kavramları, teoriği ve uygulanması ile ilgili ayrıntılı notlar içermektedir

• 🌱 Proje, DeepLearningNotes💫 adı altında İngilizce olarak başlatılmıştır, daha sonra Türkçe'ye çevrilmiştir 🚀 ve şuanda paralel yürütülmekte

🎨 Katkıda Bulunma Türleri

🌟 Dil Tarafı

• 😢 Çevrilemeyen yerleri çevirme

• 🐛 Dil hatasını giderme

• 💖 Çeviri iyileştirme

👩‍🏫 Bilgi Tarafı

• ✨ Yeni bilgi ekleme

• 🐞 Hatalı bilgiyi düzeltme

🦋 Nasıl Katkıda Bulunabilirim?

🌟 Dil Tarafı

• Çeviremediğim cümlerleri (çeviremedim 😢) yazısıyla belirtiyorum

• Her yazının sonunda, asıl projedeki karşılığına ait bir link bulunmakta, dil hatası veya anlaşılamayan bir cümle bulduğunuz zaman düzeltmek için GitHub üzerinden Pull Request açarsanız veya benle iletişime geçerseniz hoş olur ⭐ (Hatta çok hoş olur 🤗)

Hatalar basit (örn. 'yazım hatası', 'böyle olsa daha iyi anlaşılır' vs. gibi) olsa bile çekinmeden bildirmeniz çok hoş olur 🎉

👩‍🏫 Bilgi Tarafı

• Hatalı bilgi veya yeni bilgi eklemek istediğinizde bilgi kaynağını belirterek GitHub üzerinden Pull Request açarsanız veya benimle iletişime geçerseniz projeyi büyütmeme ve daha faydalı hale getirmeme yardımcı olursunuz (şimdiden teşekkür ederim 🎊)

📚 Proje Sözlüğü Hakkında

• Projedeki bütün çeviriler Proje Sözlüğüne 📕 göre yapılmıştır

• 🔎 Anlaşılamayan bir kavram bulduğunuz zaman sözlüğe bakıp İngilizce'sine bakabilirsiniz

👷‍♀️ Sözlüğün İndeksleme Kuralı

• 📚 olanlar internette araştırarak bulduğum çevirilerdir

• 🦋 olanlar kişisel çevirilerdir (iyileştirilebilir 👩‍🔧)

• ❓ olanlar, daha çeviremediğim kavramlar (yardıma ihtiyaç var 🆘)

DeepLearningTürkiye sözlüğüne teşekkürler 🤗

👷‍♀️ Ağ Görselleştirme Aracı

• Ağın grafiğini görselleştir

• Netron ✨

💫 CNN Giriş / Çıkış Görselleştirme Aracı

• CNN'deki her bir katmanın giriş ve çıkışlarını izle

• Tensorspace 🎉

🖼️ OpenImages İndirme Aracı

• 🚀 Sınıflarına göre resimleri indirin

• 🔗 OID

🔗 Toplu Bağlantı İndirme Aracı

• 💁‍♀️ Toplu bağlantıları tek tıklamayla indirin

• 👩‍💻 Google Chrome eklentisi

• ⚓ Tab Save

Aktivasyon Fonksiyonlarının temel amacı, bir A-NN'deki bir düğümün giriş sinyalini bir dönüşüm uygulayarak bir çıkış sinyaline dönüştürmektir. Bu çıkış sinyali şimdi yığındaki bir sonraki katmana girdi olarak kullanılır.

📃 Aktivasyon Fonksiyonlarının Türleri

📈 Lineer Aktivasyon Fonksiyonu (Birim Fonksiyonu)

Formül:

$linear(x)=x$

Grafik:

Regresyon problemlerindeki çıktı katmanında kullanılabilir.

🎩 Sigmoid Fonksiyonu

Formül:

$sigmoid(x)=\frac{1}{1+exp(-x)}$

Grafik:

🎩 Tangent Fonksiyonu

Neredeyse her zaman sigmoid fonksiyonundan üstündür

Formül:

$tanh(x)=\frac{2}{1+e^{-2x}}-1$

Sigmoid fonksiyonunun kaydırılmış versiyonu 🤔

Grafik:

Aktivasyon fonksiyonları farklı katmanlar için farklı olabilir, örneğin, gizli katman için tanh fonksiyonunu, çıkış katmanı için sigmoid fonksiyonunu kullanabiliriz

🙄 Tanh ve Sigmoid Dezavantajları

Eğer z çok büyükse veya çok küçükse, bu fonksiyonun türevi (veya eğimi) çok küçük olur (0'a yakın olur) ve bu, gradient descent'i yavaşlatabilir. 🐢

🎩 Doğrultulmuş Doğrusal Aktivasyon Ünitesi (Relu ✨)

Başka ve çok popüler bir seçenek

Formül:

Grafik:

Yani türev, z pozitif olduğunda 1 ve z negatif olduğunda 0'dır.

Dezavantaj: z negatif iken türev=0'dır 😐

🎩 Sızdıran Relu

Formül:

Grafik:

Veya: 😛

🎀 Relu'nun Avantajları

• Z uzayının çoğu, aktivasyon fonksiyonunun türevi, 0'dan çok farklıdır.

• NN tanh veya sigmoid kullanmaya göre çok daha hızlı öğrenecektir.

🤔 NN'lerin neden doğrusal olmayan aktivasyon fonksiyonlara ihtiyacı var?

Peki, eğer lineer işlevi kullanırsak, NN sadece girişin lineer bir fonksiyonunu çıkarır, yani NN'nin kaç katmanı olursa olsun 🙄, yaptığı tek şey sadece lineer bir fonksiyonu hesaplamaktır 😕

❗ İki doğrusal fonksiyonun kompozisyonunun kendisinin doğrusal bir fonksiyon olduğunu unutma

👩‍🏫 Aktivasyon Fonksiyonu Seçmek İçin Kurallar

• Eğer çıkış 0 veya 1 ise (ikili sınıflandırma) ➡ sigmoid çıkış katmanı için uygundur

• Diğer bütün birimler için ➡ Relu ✨

Aktivasyon fonksiyonu için Relu'nun varsayılan seçenek olduğunu söyleyebiliriz

Not:

Bu fonksiyonlardan hangisinin en iyi sonucu verdiğinden emin değil isen 😵, hepsini dene 🤕 ve farklı doğrulama setleri üzerinden değerlendir ve hangisinin daha iyi çalıştığını gör ve kullan 🤓😇

🌞 Yazının Aslı

• Burada 🐾

🧐 Daha Fazla Oku

• Which Activation Function Should I Use? (Siraj Raval ✨)

• Activation Functions in Neural Networks

• Understanding Activation Functions in Neural Networks

Yapay Sinir Ağlarının temel kavramları

🍭 Temel Sinir Ağı

Convention: Giriş katmanı sayılmadığından görüntüdeki NN 2 kat NN olarak adlandırılır 📢❗

📚 Terimler

🧠 Yapay bir nöron ne yapar?

Girişinin ağırlıklı toplamını hesaplar, bias ekler ve ardından bir aktivasyon fonksiyonu nedeniyle nöronun tetiklenip tetiklenmeyeceğine karar verir.

Aktivasyon fonksiyonları ile ilgili ayrıntılı notlarım: burada 👩‍🏫

👩‍🔧 Parametre Boyut Kontrolü

Bu boyutların doğru olduğundan emin olmak, daha iyi ve hatasız 🐛 kodlar yazmamıza yardımcı olur.

🎈 İleri Yayılım Sürecinin Özeti

👩‍🔧 Vektörize Edilmiş Denklemler:

$Z^{[l]} =W^{[l]}A^{[l-1]}+b^{[l]}$ $A^{[l]} = g^{[l]}(Z^{[l]})$

🎈 Geri Yayılım Sürecinin Özeti

Vektörize Edilmiş Denklemler:

$dZ^{[l]}=dA^{[l]} * {g^{[l]}}'(Z^{[l]})$

$dW^{[l]}=\frac{1}{m}dZ^{[l]}A^{[l-1]T}$

$db^{[l]}=\frac{1}{m}np.sum(dZ^{[l]}, axis=1, keepdims=True)$

$dA^{[l-1]}=W^{[l]T}dZ^{[l]}$

➰➰ İleri ve Geri Yayılımı Bir Arada

😵🤕

✨ Parametreler ve Hiper-parametreler

👩‍🏫 Parametreler

• $W^{[1]}, W^{[2]}, W^{[3]}$

• $b^{[1]}, b^{[2]}$

• ......

👩‍🔧 Hiper-parametreler

• Öğrenme hızı

• İterasyon sayısı

• Gizli katmanların sayısı

• Gizli birimlerin sayısı

• Aktivasyon Fonksiyonunun Seçimi

• ......

Hiper-parametrelerin parametreleri kontrol ettiğini söyleyebiliriz 🤔

🌞 Yazının Aslı

• Burada 🐾

📚 Terimler

Bir skalar sıfır rank'a sahip sayılır ❗❕

🔩 Vektörleştirme (Vectorization)

Vektörleştirme, Python veya Matlab kodunu döngü kullanmadan hızlandırmak için kullanılır. Böyle bir fonksiyon kullanmak kodun çalışma süresini verimli bir şekilde en aza indirmeye yardımcı olabilir. Vektörlerin nokta çarpımı (dot product), vektörlerin dış çarpımı (outer products) ve Hadamard Çarpımı (element wise multiplication) gibi çeşitli işlemler vektörler üzerinden gerçekleştirilebilmektedir.

➕ Avantajlar

• Daha hızlı (paralel işlemlere izin verir) 👨‍🔧

• Daha basit ve daha okunabilir kod ✨

👀 Görselleştirme

👩‍💻 Kod Örnekleri:

İki dizinin nokta çarpımını bulma:

import numpy as np
array1 = np.random.rand(1000)
array2 = np.random.rand(1000)

# Vektorize edilmeyen versiyon
result=0
for i in range(len(array1)):
  result += array1[i] * array2[i]
# result: 244.4311

# Vektorize edilen versiyon
v_result = np.dot(array1, array2)
# v_result: 244.4311

📈 Bir dizinin (veya matrisin) her elemanına üstel işlem uygulanması

array = np.random.rand(1000)
exp = np.exp(array)

🚀 Sigmoid Fonksiyonunun Vektörleştirilmiş Versiyonu

array = np.random.rand(1000)
sigmoid = 1 / (1 + np.exp(-array))

👩‍💻 Numpy'de Desteklenen Yaygın İşlemler

🤸‍♀️ Yaygın Tek Dizi Fonksiyonları

• Dizideki her elemanın karekökünü alma

  • np.sqrt(x)

• Dizinin tüm elemanlarının toplamını almak

  • np.sum(x)

• Dizideki her bir elemanın mutlak değerini alma

  • np.abs(x)

• Dizideki her elemana trigonometrik fonksiyonlar uygulama

  • np.sin(x), np.cos(x), np.tan(x)

• Dizideki her bir eleman üzerine logaritmik fonksiyonlar uygulama

  • np.log(x), np.log10(x), np.log2(x)

🤸‍♂️ Yaygın Çoklu Dizi Fonksiyonları

• Aritmetik işlemleri dizilerdeki karşılık gelen elemanlara uygulama

  • np.add(x, y), np.subtract(x, y), np.divide(x, y), np.multiply(x, y)

• Dizideki karşılık gelen elemanlara kuvvet işlemi uygulama

  • np.power(x, y)

➰ Yaygın Dizili Sequence Fonksiyonlar

• Bir dizinin ortalamasını bulma

  • np.mean(x)

• Bir dizinin medyanını bulma

  • np.median(x)

• Bir dizinin varyansını bulma

  • np.var(x)

• Bir dizinin standart sapmasını bulma

  • np.std(x)

• Bir dizinin maximum ve minimum değerini bulma

  • np.max(x), np.min(x)

• Bir dizinin maximum ve minimum değerinin indisini bulma

  • np.argmax(x), np.argmin(x)

💉 Yayma

Aritmetik işlemler sırasında numpy'nin farklı boyutlardaki dizileri nasıl ele aldığını açıklar. Bazı kısıtlamalara bağlı olarak, daha küçük dizi daha büyük dizi boyunca yayınlanır, böylece uyumlu şekillere sahip olurlar.

Uygulamalı olarak:

Elimizde (m,n) boyutundaki A matrisi olsun. (1,n) boyutundaki B matrisi ile toplamak / çıkarmak / çarpmak / bölmek istiyorsak, B matrisi m kez kopyalanacak, daha sonra istenen işlem gerçekleşecek.

Aynı şekilde: Elimizde (m,n) boyutundaki A matrisi olsun. (m,1) boyutundaki B matrisi ile toplamak / çıkarmak / çarpmak / bölmek istiyorsak, B matrisi n kez kopyalanacak, daha sonra istenen işlem gerçekleşecek.

Uzun lafın kısası: Farklı boyutlardaki diziler (veya matrisler) toplanamaz, çıkartılamaz veya genel olarak aritmetik olarak kullanılamaz. Dolayısıyla, boyutları genişletmek bunu mümkün kılmanın bir yoludur, böylece uyumlu şekillere sahip olurlar.

👀 Görselleştirme

👩‍💻 Kod Örnekleri

(1,n) boyutundaki vektörü (2,n) boyutundaki matrise ekleme

a = np.array([[0, 1, 2], 
              [5, 6, 7]] )
b = np.array([1, 2, 3])
print(a + b)

# Output: [[ 1  3  5]
#          [ 6  8 10]]

➖ Bir matristen 'a' skalar çıkartma

a = np.array( [[0, 1, 2], 
               [5, 6, 7]] )
c = 2
print(a - c)
# Output: [[-2 -1  0]
#          [ 3  4  5]]

1️⃣ Rank-1 Dizisi

👩‍💻 Kod Örneği

x = np.random.rand(5)
print('shape:', x.shape, 'rank:', x.ndim)

# Output: shape: (5,) rank: 1

y = np.random.rand(5, 1)
print('shape:', y.shape, 'rank:', y.ndim)

# Output: shape: (5, 1) rank: 2

z = np.random.rand(5, 2, 2)
print('shape:', z.shape, 'rank:', z.ndim)

# Output: shape: (5, 2, 2) rank: 3

Rank-1 dizilerinin kullanılmaması tavsiye edilmektedir

🤔 Neden Rank-1 dizilerinin kullanılmaması tavsiye edilir?

Rank-1 Dizileri, bulunması ve düzeltilmesi zor olan hatalara neden olabilir, örneğin:

Rank-1 dizilerindeki dot işlemi:

a = np.random.rand(4)
b = np.random.rand(4)
print(a)
print(a.T)
print(np.dot(a,b))

# Output
# [0.40464616 0.46423665 0.26137661 0.07694073]
# [0.40464616 0.46423665 0.26137661 0.07694073]
# 0.354194202098512

Rank-2 dizilerindeki dot işlemi:

a = np.random.rand(4,1)
b = np.random.rand(4,1)
print(a)
print(np.dot(a,b))

# Output
# [[0.68418713]
# [0.53098868]
# [0.16929882]
# [0.62586001]]
# [[0.68418713 0.53098868 0.16929882 0.62586001]]
# ERROR: shapes (4,1) and (4,1) not aligned: 1 (dim 1) != 4 (dim 0)

Özet: Kodlarımızı daha hatasız ve kolay hata ayıklamak için rank-1 dizilerini kullanmaktan kaçınmalıyız 🐛

🌞 Yazının Aslı

• Burada 🐾

🧐 Referanslar

• Official Documentation of Broadcasting in NumPy

Lojistik regresyona benzeterek anlayabiliriz: 😋

Lojistik regresyonun 0 ile 1,0 arasında bir ondalıklı sayı ürettiğini hatırla, Örneğin, bir e-posta sınıflandırıcısından 0,8'lik bir lojistik regresyon çıktısı, bir e-postanın% 80'i spam olma olasılığını ve% 20'sinin spam olmadığını gösterir. Yani, bir e-postanın spam olma ve spam olmama ihtimalinin toplamı 1.0'dir.

Softmax bu fikri ÇOKLU-SINIF dünyasına genişletiyor. Yani, Softmax, her sınıfa çok sınıflı bir problemde ondalık olasılıklar verir. Bu olasılıkların toplamı 1.0'e eşittir.

• Onun diğer ismi Maximum Entropy (MaxEnt) Classifier

Softmax regresyonunun lojistik regresyonun genelleştirdiğini söyleyebiliriz.

Lojistik regresyon, C = 2 olan softmax'ın özel bir durumudur 🤔

📚 Notasyon

C = sınıf sayısı = çıkış katmanının birim sayısı

🎨 Softmax Katmanı

Softmax, çıktı katmanından hemen önce bir sinir ağı katmanı vasıtasıyla uygulanır. Softmax katmanı, çıkış katmanı ile aynı sayıda düğüme sahip olmalıdır.

💥 Softmax Aktivasyon Fonksiyonu

🔨 Hard Max Fonksiyonu

Softmax katmanının çıktısını alır ve 1 vs 0 vector (adlandırdığıma göre 🤭) vektörüne dönüştürür, o da bizim ŷ'iz olacak

Örenğin:

Ve bunun gibi 🐾

🔎 Kayıp Fonksiyonu

Y ve ŷ (C,m) boyutunda matrislerdir 👩‍🔧

🌞 Yazının Aslı

🧐 Daha Fazla Oku

🚩 Tensorflow'daki programların ana akışı

1. Daha işletilmemiş tensör leri oluştur

2. Tensör'lerin arasındaki işlemeleri yaz

3. Tensor'ları başlat (initialize)

4. Bir Session oluştur

5. Session'ı çalıştır. Bu, yukarıda yazdığın işlemleri yürütecektir.

Özetle, değişkenleri başlat, bir Session oluştur ve Session'ın içindeki işlemleri çalıştır 👩‍🏫

👩‍💻 Kod Örneği

Aşağıdaki formülü hesaplamak için:

$loss=L(\hat{y},y)=(\hat{y}^{(i)}-y^{(i)})^2$

# Tensörleri oluşturma ve arasındaki işlemi yapma 
y_hat = tf.constant(36, name='y_hat')
y = tf.constant(39, name='y')
loss = tf.Variable((y - y_hat)**2, name='loss')

# Tensörleri başlatma
init = tf.global_variables_initializer()

# Session oluşturma
with tf.Session() as session: 
    # İşlemeleri çalıştırma
    session.run(init) 

    # Sonuçları yazdırma
    print(session.run(loss))

Kayıp fonksiyonu için bir değişken oluşturduğumuzda, loss'u basitçe diğer miktarların bir fonksiyonu olarak tanımladık, ancak değerini değerlendirmedik. Bunu değerlendirmek için initializer'ı kullanırız.

❗ Değişken Başlatma (initalization) Hakkında Not

Aşağıdaki kod için

a = tf.constant(2)
b = tf.constant(10)
c = tf.multiply(a,b)
print(c)

🤸‍♀️ Çıktı:

Tensor("Mul:0", shape=(), dtype=int32)

Beklendiği gibi, 20 görmeyeceğiz 🤓! Sonucun shape attribute'u olmayan ve "int32" türünde bir tensör olduğunu söyleyen bir tensörümüz var. Tek yaptığımız 'computation graph' koymaktı, ancak henüz bu hesaplamayı çalıştırmadık.

📦 TF'deki Placeholders

• Yer tutucu placeholder, değerini ancak daha sonra belirleyebileceğiniz bir nesnedir. Bir yer tutucunun değerlerini belirtmek için, bir feed dictionary kullanarak değerleri iletebiliriz.

• Aşağıda, x için bir yer tutucu oluşturuldu. Bu, Session'ı çalıştırdığımızda daha sonra bir sayı girmemizi sağlar.

x = tf.placeholder(tf.int64, name = 'x')
print(sess.run(2 * x, feed_dict = {x: 3}))
sess.close()

🎀 Daha Fazla Örnek

Sigmoid Fonksiyonun değerini TF ile hesaplamak

def sigmoid(z):
    """
    z değeri için sigmoid fonksiyonunu hesaplar

    Argümanlar:
    z -- giriş değeri, skaler veya vektör

    Dönüş değeri: 
    results -- z'nin sigmoid değeri 
    """

    # x için yertutucu tanımlama. adı da 'x'.
    x =  tf.placeholder(tf.float32, name = 'x')

    # sigmoid(x)'i hesaplama
    sigmoid = tf.sigmoid(x)

    # session oluşturma, ve çalıştırma.
    with tf.Session() as sess:
        # session'ı çalıştırma ve sonuçları output'a (result'a) atama
        result = sess.run(sigmoid, feed_dict = {x: z})

    return result

Maliyet Fonksiyonun değerini TF ile hesaplamak

def cost(logits, labels):
    """
    sigmoid cross entropy ile cost fonksiyonunun değerini hesaplar

    Argümanlar:
    logits -- z'yi içeren bir vektör, Son lineer ünitenin çıktısı (son sigmoid aktivasyonundan önce)
    labels -- y - etiket vektörü (1 veya 0) 

    Dönüş Değeri:
    cost -- Cost fonksiyonunun session'ını çalıştırır
    """

    # "logits" (z) ve "labels" (y) için yer tutucu oluşturma 
    z = tf.placeholder(tf.float32, name = 'z')
    y = tf.placeholder(tf.float32, name = 'y')

    # Loss fonksiyonunu kullanma
    cost = tf.nn.sigmoid_cross_entropy_with_logits(logits = z,  labels = y)

    # Session oluşturma
    sess = tf.Session()

    # Session'ı çalıştırma 
    cost = sess.run(cost, feed_dict = {z: logits, y: labels})

    # Session'ı kapatma
    sess.close()

    return cost

🌞 Yazının Aslı

• Burada 🐾

📈 Veri Normalleştirme

Veri Hazırlama'nın bir parçasıdır

• Elimizde, hepsi pozitif ya da negatif olan bir özellik varsa bu, bunları içeren katmandaki düğümler için öğrenmeyi zorlaştıracaktır. Sigmoid aktivasyon fonksiyonunu izleyenler gibi zikzak yapmak zorunda kalacaklar.

• Verilerimizi sıfıra yakın bir ortalama olacak şekilde dönüştürürsek, hem pozitif değerlerin hem de negatif değerlerin olduğundan emin olacağız.

Formül:

$normalized=\frac{x_{i}-\mu }{\sigma}$

Fayda: Bu, Maliyet Fonksiyonunun J optimizasyonunu hem daha hızlı hem de daha kolay yapar 😋

🚩 NN'i uygulamadan önce iyi düşünülmesi gerekenler

Katman sayısı, gizli birimlerin sayısı, öğrenme hızı, aktivasyon fonksiyonları...

İlk seferinde hepsini doğru seçmek çok zor, bu yüzden bunu iteratif bir süreç olarak ele almamız lazım.

Fikir ➡ Kod ➡ Deney ➡ Fikir 🔁

Yani burada mesele, bu döngüde nasıl verimli bir şekilde dolaşılacağıdır 🤔

👷‍♀️ Eğitim, Doğrulama ve Test Verilerinin Ayrılması

İyi bir değerlendirme için veri setini aşağıdaki gibi bölmek iyidir:

🤓 Eğitim Seti

Modeli eğitmek için kullandığımız gerçek veri seti (NN durumunda ağırlık ve yanlılık).

Model bu verilerden görür ve öğrenir 👶

😐 Doğrulama Seti

Model hiper-parametrelerini ayarlarken eğitim setine uygun bir modelin yansız bir değerlendirmesini sağlamak için kullanılan veri örneği. Doğrulama setindeki beceri, model konfigürasyonuna dahil edildiğinden değerlendirme daha yanlı hale gelir.

Model bu verileri görür, ancak bunlarda asla öğrenmez 👨‍🚀

🧐 Test Seti

Eğitim setine uygun son bir modelin yansız bir değerlendirmesini sağlamak için kullanılan veri örneği. Modeli değerlendirmek için kullanılan altın standardı sağlar 🌟.

Uygulama Notu: Test seti, gerçek dünyada kullanıldığında modelin karşılaşacağı çeşitli sınıfları kapsayan dikkatlice örneklenmiş verileri içermelidir 🚩🚩🚩❗❗❗

Sadece model tamamen eğitildiğinde kullanılır 👨‍🎓

😕 Yanlılık (Bias) / Varyans (Variance)

🕹 Yanlılık

Yanlılık, tahmin edilen değerlerin gerçek değerlerden ne kadar uzak olduğunu gösteren bir kavramdır. Ortalama öngörülen değerler gerçek değerlerden uzaksa yanlılık yüksektir.

Yüksek yanlılığa sahip olmak, modelin çok basit olduğunu ve verilerin karmaşıklığını yakalamadığını Eksik öğrendiğini (underfitting) ve bu nedenle verilere uygun olmadığını gösterir. 🤕

🕹 Varyans

• Varyans, belirli bir veri noktası için model tahmininin değişkenliği veya bize verilerimizin yayılmasını söyleyen bir değerdir.

• Varyansı yüksek olan model, daha önce görmediği verilerde genelleme yapamamaktadır.

Yüksek varyansa sahip olmak algoritmanın eğitim verilerindeki rastgele gürültüyü modellediğini ve verileri aşırı öğrendiğini (overfitting) gösterir. 🤓

👀 Varyans / Yanlılık Görselleştirilmesi

↘ Modeli Uygularken..

İstenilen performansı elde edemezsek modelimizi geliştirmek için şu soruları sormamız gerekir:

Aşağıdaki çözümlerin performansını doğrulama seti üzerinden kontrol ediyoruz

1. Yüksek yanlılık var mıdır? varsa, bu bir eğitim problemidir, yapılabilecekler:

   • Daha büyük bir ağ dene

   • Daha uzun eğit

   • Daha iyi optimizasyon algoritması dene

   • Başka bir NN mimarisini dene

Bunun yapısal bir sorun olduğunu söyleyebiliriz 🤔

1. Yüksek varyans var mıdır? varsa, doğrulama seti performans problemidir, yapılabilecekler:

   • Daha fazla veri kullan

   • Düzenlileştirme (Regularization) yap

     • L2, dropout, data augmentation

Belki veri ya da algoritmik bir problem olduğunu söyleyebiliriz. 🤔

1. Yüksek varyans veya yüksek yanlılık yok mu?

TADAAA işimiz bitti 🤗🎉🎊

🌞 Yazının Aslı

• Burada 🐾

🧐 Referanslar

• About Train, Validation and Test Sets in Machine Learning

• Bias and Variance in Machine Learning

Kısaca: Aşırı öğrenmeyi önleyen -ve varyansı- azaltan bir tekniktir

🙄 Problem

Aşırı öğrenme durumunda, modelimiz eğitim verilerindeki ayrıntıları ve gürültüyü çok iyi öğrenmeye çalışır, bu da sonuçta görülmeyen verilerde (test seti) düşük performansa neden olur.

Aşağıdaki grafik, bu durumu daha iyi açıklar:

👩‍🏫 Düzenlileştirme Daha İyi Tanımı

Modelin daha iyi genelleşmesi için öğrenme algoritmasında ufak değişiklikler yapan bir tekniktir. Bu da modelin görülmeyen veriler üzerindeki performansını artırmaktadır.

🔨 Düzenlileştirme Teknikleri

🔩 L2 Düzenlileştirmesi (Weight Decay)

En yaygın düzenlileştirme türüdür, aşağıdaki formüle göre uygulanır

Burada, lambda düzenlileştirme parametresidir. Daha iyi sonuçlar için değeri optimize edilmiş olan hiper-parametredir. L2 düzenlileştirmesi, ağırlıkları sıfıra (ancak tam olarak sıfıra değil) indirgemeye zorladığı için ağırlık azalması (Weight decay) olarak da bilinir.

🔩 Sönümleme (Dropout)

Bazı sinirleri rastgele belirli bir oranda elimine ederek başka bir düzenlileştirme yöntemidir.

Basitçe: Her p olasılığına sahip düğüm için, geri yayılma sırasında giriş veya çıkış ağırlıklarını güncellemiyoruz (Yani onu düşürüyoruz 😅)

Daha iyi görselleştirme:

Eleme işleminden önce ve sonra bir NN

Genellikle bilgisayarlı görüşte kullanılır, ancak olumsuz yönü maliyet fonksiyonu J'nin artık iyi tanımlanmamasıdır.

🤡 Veri Artırma (Data Augmentation)

Aşırı öğrenmeyi azaltmanın en basit yolu, eğitim verilerinin boyutunu artırmaktır, daha fazla veri elde etmek çok maliyetli olduğu için her zaman mümkün değildir, ancak bazen verilerimize dayanarak verilerimizi artırabiliriz, örneğin:

• Resimler üzerinde dönüşüm yapmak veri setimizi büyütebilir

🛑 Erken Durdurma

Eğitim setinin bir bölümünü doğrulama seti olarak tuttuğumuz bir tür çapraz doğrulama stratejisidir. Doğrulama setindeki performansın kötüye gittiğini gördüğümüzde, modelin eğitimini derhal durdururuz. Bu Erken Durma olarak bilinir.

🌞 Yazının Aslı

🧐 Daha Fazla Oku

Hızlı ve iyi optimizasyon algoritmalarına sahip olmak tüm işin verimliliğini hızlandırabilir ✨

🔩 Toplu Gradyan İnişi (Batch Gradient Descent)

Toplu gradyan inişinde, gradyan inişinin her yinelemesinde maliyet fonksiyonunun gradyanını hesaplamak için tüm veri kümesini kullanırız ve ardından ağırlıkları güncelleriz.

• Tüm veri kümesini hesaplamada kullandığımızdan dolayı gradyanın yakınsaması yavaştır.

🎩 Stokastik Gradyan İnişi (SGD)

Stokastik Gradyan İnişi'nde, gradyanı hesaplamak ve ağırlıkları her bir yinelemeyle güncellemek için tek bir veri noktası veya örnek kullanıyoruz, tamamen rastgele bir veri setini alabilmemiz için önce veri kümesini karıştırmamız gerekir.

Rastgele örnek, global bir minimuma ulaşmaya yardımcı olur ve yerel bir minimumda takılıp kalmayı önler.

• Büyük bir veri kümesi için öğrenme çok daha hızlı ve yakınsama çok hızlı 🚀

🔩 Mini-Toplu Gradyan İnişi (Mini Batch Gradient Descent)

• Tek bir eğitim örneği yerine, örneklerin küçük bölümünün kullanıldığı bir Stokastik Gradyan İnişinin bir varyasyonudur.

• Yaygın olarak kullanılır, daha hızlı yakınsar ve daha stabildir

• Bölüm büyüklüğü veri kümesine bağlı olarak değişebilir

1 ≤ batch-size ≤ m, batch-size bir hiper-parametredir ❗

🔃 Karşılaştırma

• Çok büyük batch-size (m veya m'ye yakın):

  • Her yineleme için çok uzun

• Çok küçük batch-size (1 veya 1'e yakın)

  • Vektörleştirme hızını kaybetme

• Ne çok büyük ne çok küçük batch-size

  • Vektörleştirme yapabiliriz

  • Her yineleme için iyi hız

  • En hızlı (en iyi) öğrenme 🤗✨

🚩 Batch-Size Seçmek İçin Kurallar

• Küçük bir veri kümesi için (m ≤ 2000) ➡ bölümlü gradyan inişi kullan

• Tipik mini batch-size: 64, 128, 256, 512, 1024'e kadar

• mini batch-size CPU / GPU belleğine sığdığından emin ol

mini batch-size 2 kuvveti olarak seçmek daha iyidir (daha hızlı) (bellek sorunları nedeniyle) 🧐

🔩 Momentumlu Gradyan İnişi (Gradient Descent with Momentum)

Hemen hemen her zaman, momentumlu gradyan inişi, standart gradyan inişi algoritmasından daha hızlı yakınsar. Standart gradyan inişi algoritmasında, algoritmayı yavaşlatan bir yönde daha büyük ve başka bir yönde daha küçük adımlar atmamızdır 🤕

Bu momentumun geliştirebileceği şeydir, salınımı bir yönde kısıtlar, böylece algoritmamız daha hızlı yakınsayabilir. Ayrıca, y yönünde atılan adımların sayısı sınırlı olduğu için daha yüksek bir öğrenme hızı belirleyebiliriz 🤗

Aşağıdaki resim durumu daha iyi anlatmaktadır: 🧐

Formül:

Daha iyi anlamak için:

Momentumlu gradyan inişinde, gradyan inişini hızlandırmaya çalışırken şunu söyleyebiliriz:

• Türevler hızlandırıcıdır

• v'ler hızdır

• β sürtünmedir

🔩 RMSprop En İyileyicisi

RMSprop optimizer, momentumlu gradyan inişi algoritmasına benzer. RMSprop en iyileyicisi salınımları dikey yönde kısıtlar. Bu nedenle, öğrenme hızımızı artırabiliriz ve algoritmamız yatay doğrultuda daha hızlı yaklaşırken daha büyük adımlar atabilir.

RMSprop ve gradyan inişi arasındaki fark, gradyanlarım nasıl hesaplandığıdır, RMSProp gradyanları aşağıdaki formülle hesaplar:

✨ Adam En İyileyicisi

Açılımı: ADAptive Moment estimation

Günümüzde yaygın olarak kullanılan algoritmadır, Adam, RMSprop ve Stokastik Gradyan İnişi'nin momentum ile bir kombinasyonu olarak görülebilir. RMSprop gibi öğrenme hızını ölçeklendirmek için kare gradyanları kullanır ve momentum ile SGD gibi gradyan yerine gradyanın hareketli ortalamasını kullanarak momentumdan yararlanır.

Özetle: Adam = RMSProp + GD with momentum + bias correction

😵😵😵

👩‍🏫 Hiper-parametrelerin Seçimi (önerilen değerler)

• α: ayarlanması gerekiyor

• β1: 0.9

• β2: 0.999

🌞 Yazının Aslı

🧐 Referanslar

👗 MNIST Nedir?

MNIST'in açılımı: (Modified National Institute of Standards and Technology database)

• 🔎 Fashion-MNIST 60.000 örnek eğitim setinden ve 10.000 örnek test setinden oluşur

• 🎨 Türleri:

  • 🔢 MNIST: el yazısı rakamlar için

  • 👗 Fashion-MNIST: moda için (kıyafet)

• 📃 Özellikler:

  • 🌚 Gri tonlama (siyah-beyaz)

  • 28x28 px

  • 10 farklı kategori

  • Repo

📚 Önemli Terim

Aktivasyon fonksiyonunun temel amacı, bir NN'deki bir düğümün giriş sinyalini bir çıkış sinyaline dönüştürmektir. Bu çıkış sinyali şimdi yığındaki bir sonraki katmana girdi olarak kullanılır 💥

💫 Performans Hakkında Notlar

• MNIST'deki değerler 0-255 arasındadır ancak sinir ağları normalleştirilmiş verilerle daha iyi çalışır, bu nedenle her değeri 255'e bölebiliriz, böylece değerler 0,1 arasındadır.

• Eğitim sürecini durdurmak için birden fazla kriter var, epoch sayısını ya da eşiğini ya da her ikisini birden belirleyebiliriz.

  • Epochs: iterasyon sayısı

  • Eşik: her iterasyon sonrasında accuracy veya loss için bir eşik değeri

  • Eşik değeri ve maksimum epoch sayısı

Her epoch sonunda, accuracy'yi Callbacks ile kontrol edebiliriz 💥

👩‍💻 Kodlarım

• 👗 Fashion MNIST

• 1️⃣ Digit MNIST

• 🎈 Genel Akış

• 🎨 Detaylı Sınıflandırma

🌞 Yazının Aslı

• Burada 🐾

🧐 Referanslar

• Official Documentation of Keras

• More About Activation Functions

Bu klasör CNN'ler hakkında teorik detaylar içerir.

📚 Önemli Terimler

💫 Performans Üzerine Notlar

• Bir CNN'nin eğitim hızı, hesaplama karmaşıklığından dolayı normal NN'den çok daha düşüktür 🐢

🧐 Referanslar

• More on Convolutional Neural Networks

🌞 Yazının Aslı

• Burada 🐾

CNN tabanlı çalışmalarımızı Tarayıcıda uygulamak için Tensorflow.JS kullanmalıyız 🚀

👷‍♀️ İş Akışı

1. 🚙 Import Tensorflow.js

2. 👷‍♀️ Modeli kur

3. 👩‍🏫 Eğit

4. 👩‍⚖️ Modeli kullan

🚙 Tensorflow.js' Import Etme

Tensorflow.js'yi aşağıdaki şekilde import edebiliriz

    <script 
        src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@latest">
    </script>

👷‍♀️ Modeli Kurma

😎 Python'da yaptığımız gibi:

1. 🐣 Sequential objesi tanımla

2. 👩‍🔧 Katmanları ekle

3. 🚀 Modeli derle .compile()

4. 👩‍🎓 Eğit (fit)

5. 🐥 Modeli tahmin için kullan

// create sequential 
const model = tf.sequential();

// add layer(s)
model.add(tf.layers.dense({units: 1, inputShape: [1]}));

// set compiling parameters and compile the model
model.compile({loss:'meanSquaredError', 
                optimizer:'sgd'});

// get summary of the mdoel
model.summary();

// create sample data set
const xs = tf.tensor2d([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], [6, 1]);
const ys = tf.tensor2d([-3.0, -1.0, 2.0, 3.0, 5.0, 7.0], [6, 1]);

// train
doTraining(model).then(() => {
    // after training
    predict = model.predict(tf.tensor2d([10], [1,1]));
    predict.print();
});

([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], [6, 1])

[-1.0, 0.0, 1.0, 2.0, 3.0, 4.0]: Veri seti değerleri (girişler)

[6, 1]: Girişin boyutu

👁‍🗨 Dikkat

• 🐢 Eğitim uzun bir süreç olduğundan onu asenkron bir fonksiyonda yapmalıyız

async function doTraining(model){
    const history = 
    await model.fit(xs, ys, 
        { epochs: 500,
            callbacks:{
                onEpochEnd: async(epoch, logs) =>{
                    console.log("Epoch:" 
                        + epoch 
                        + " Loss:" 
                        + logs.loss);

                }
            }
        });
}

👩‍💻 Kodun tamamı

• 🐾 Burada

🌞 Yazının Aslı

• 🐾 Burada

Her ilk uygulamada olduğu gibi, bize tüm metodoloji hakkında bir fikir veren süper basit bir şeyle başlamalıyız

✨ Keras Nedir?

Yüksek seviyeli bir Yapay Sinir Ağları API'si, Python ile yazılmış ve TensorFlow, CNTK veya Theano'nun üzerinde çalışabilir.

📚 Önemli Terimler

👩‍🔬 En Basit Sinir Ağı

Bir sinirden oluşan bir katman içerir.

👩‍💻 Kod Örneği

# modeli tanımla
model = Sequential()

# tek birimli bir katman ekleme ve girişin boyutunu belirleme 
model.add(Dense(units=1, input_shape=[1]))

# fonksiyonel özellikleri belirleme ve modeli derleme
model.compile(optimizer='sgd', loss='mean_squared_error')

Yapay sinir ağını kurduktan sonra, onu örnek verilerimizle besleyebiliriz 😋

👩‍💻 Kod Örneği

xs = np.array([-1.0,  0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

Şimdi, eğitim sürecini başlatmalıyız 🚀

👩‍💻 Kod Örneği

model.fit(xs, ys, epochs=500)

Her şey tamamlandı😎! Şimdi sinir ağımızı yeni verilerle test edebiliriz 🎉

👩‍💻 Kod Örneği

print(model.predict([10.0]))

👩‍💻 Benim Kodum

• Tam kaynak kodu burada 🐾

🔃 Geleneksel Programlamaya vs. Makine Öğrenmesi

🌞 Yazının Aslı

• Burada 🐾

🧐 Referanslar

• Official Documentation of Keras

• More About Sequential model

• More About Optimizers in Keras

• More About Loss Functions in Keras

📚 Önemli Terim

🎀 Konvolüsyon Örneği

🤔 -7'yi nasıl bulduk?

element wise çarpma yaptık, sonra sonuç matrisinin toplamını hesapladık; yani:

Ve diğer elemanlar için bu şekilde devam eder 🙃

👼 Hesaplamayı Görselleştirme

🔎 Kenar Algılama

Konvolüsyon işleminin bir uygulaması

🔎 Kenar Algılama Örnekleri

Sonuç: yatay çizgiler ortaya çıkıyor

Sonuç: dikey çizgiler ortaya çıkıyor

🙄 Ya Diğer Sayılar?

Filtrenin elemanlarına sayı koyabileceğimiz pek çok yol var.

Örneğin, Sobel filtresi bu şekildedir:

Scharr filtresi de bu şekildedir:

Prewitt filtresi:

Yani buradaki kritik nokta orta satıra dikkat etmek.

Ve Roberts filtresi:

✨ Başka Bir Yaklaşım

Bu sayıları ML yaklaşımı ile ayarlayabiliriz; Filtrenin bir ağırlık grubu olduğunu diyebiliriz, yani:

Bu sayede, elle elde etmek yerine otomatik olarak yatay, dikey, açılı veya herhangi bir kenar tipini öğrenebiliriz.

🤸‍♀️ Hesaplamalı Detaylar

n*n'lik bir resmimiz varsa ve f*f'lik bir filtre uygulamak istersek, sonuç resmi n-f+1*n-f+1 boyutunda olacaktır

😐 Olumsuz Yanları

1. 🌀 Çok fazla filtre uygularsak, görselimiz küçülür.

2. 🤨 Köşelerdeki piksellere yeterince dokunulmadığından, görüntünün kenarlarından birçok bilgi göz ardı ediliyor

💡 Çözüm

🌞 Yazının Aslı

🧐 Referanslar

Kavramları toplamak için P1 ve P2 'de açıklanan kavramların görselleştirilmesi

💫 Konvolüsyon

Özellikleri çıkarmak için filtre uygulama 🤗

Problem 😰: Görüntüler küçülüyor 😱

😏 Dolgulamaya Bir Göz At

Görüntüler Çok Büyük, Performans Düşük 😔

😉 Pooling' Bakalım

🙄 Peki, RGB resmim var

Filtrelerin renk kanalı sayısına eşit derinliğe sahip olması gerekir

🤡 Tamam, n tane filtre uygulamak istiyorum

Çıktının derinliği n ye eşit olacaktır

🤗 Tam Bir Örnekle Anlamanı Kontrol Et

🌞 Yazının Aslı

• Burada 🐾

🧐 Referanslar

• DeepLearning series: Convolutional Neural Networks (😍✨✨✨)

📚 ML'de Genel Kod Parçaları

💥 Sigmoid Fonksiyonu

def sigmoid(x):
    """
    Argümanlar:
    x -- Skaler, dizi veya matris

    Dönüş değeri:
    result -- sigmoid(x)
    """

    result = 1 /( 1 + np.exp(-x) )

    return result

🚀 Sigmoid Gradient

    def sigmoid_derivative(x):
    """
    Sigmoid fonksiyonunun gradient'ını (eğim veya türev olarak da adlandırılır), x girdisine göre hesaplar
    Argümanlar:
    x -- scaler veya Numpy dizisi

    Dönüş değeri:
    ds -- Hesaplanan gradient.
    """

    s = 1 / (1 + np.exp(-x))
    ds = s * (1 - s)

    return ds

👩‍🔧 Dizileri (Veya resimleri) Yeniden Şekillendirme

    def arr2vec(arr, target):
     """
    Argümanlar:
    image -- (length, height, depth) boyutunda bir Numpy dizisi

    Dönüş değeri:
    v -- (length*height*depth, 1) boyutunda bir vektör
    """

    v = image.reshape(image.shape[0] * image.shape[1] * image.shape[2], 1)

    return v

💥 Satırları Normalize Etme

def normalizeRows(x):
    """
    Argümanlar:
    x -- (n, m) boyutunda bir Numpy dizisi

    Dönüş değeri:
    x -- Normalize edilmiş (satıra göre) Numpy matrisi.
    """

    # Normları hesaplama
    x_norm = np.linalg.norm(x, axis=1, keepdims=True)

    # x'i normuna bölme 
    x = x / x_norm

    return x

🎨 Softmax Fonksiyonu

 def softmax(x):
    """X girişinin her satırı için softmax değerini hesaplar.

    Argümanlar:
    x -- (n,m) boyutunda bir matris

    Dönüş değeri:
    s -- (X, m) şeklindeki softmax x değerine eşit bir matris matrisi
    """

    # Exp () element-wise komutunu x'e uygulama
    x_exp = np.exp(x)

    # X_exp'nin her satırını toplayan bir vektör x_sum oluşturma
    x_sum = np.sum(x_exp, axis=1, keepdims=True)

    # Softmax (x)'in x_exp'i x_sum ile bölerek hesaplanması.
    # numpy broadcasting otomatik olarak kullanılacak
    s = x_exp / x_sum

    return s

🤸‍♀️ L1 Loss Fonksiyonu

def L1(yhat, y):
    """
    Argümanlar:
    yhat --  m boyutunda bir vektör (tahmin edilen etiketler)
    y -- m boyutunda bir vektör (doğru etiketler)

    Dönüş değeri: 
    loss -- yanda tanımlanan L1 fonksiyonunun değeri
    """

    loss = np.sum(np.abs(y - yhat))

    return loss

🤸‍♂️ L2 Loss Fonksiyonu

def L2(yhat, y):
    """
    Argümanlar:
    yhat -- m boyutunda bir vektör(tahmin edilen etiketler)
    y -- m boyutunda bir vektör(doğru etiketler)

    Dönüş değeri:
    loss -- yanda tanımlanan L1 fonksiyonunun değeri
    """

    loss = np.sum((y - yhat) ** 2)

    return loss

🏃‍♀️ Yayılma Fonksiyonnu Propagation Function

def propagate(w, b, X, Y):
    """
    Cost fonksiyonunu ve gradient'leri hasaplamanın emplemantasyonu

    Argümanlar:
    w -- ağırlıklar, (num_px * num_px * 3, 1) boyutunda bir Numpy dizisi
    b -- önyargı (bias), bir skalerdir
    X -- (num_px * num_px * 3, örnek sayısı) boyutunda veriler
    Y -- doğru etiket vektörü (kedi değilse 0, kediyse 1), (1, örnek sayısı) boyutunda

    Dönüş değeri:
    cost -- lojistik regresyon için negatif log olabilirlik cost'u
    dw -- w'ye göre kaybın gradyanı, bu nedenle w ile aynı boyutta
    db -- b'ye göre kaybın gradyanı, bu nedenle b ile aynı boyutta

    """

    m = X.shape[1]

    # İLERİ YAYILMA (X’DEN MALİYETE)

    # aktivasyonu hesaplama
    A = sigmoid( np.dot(w.T, X) + b ) 

    # cost'u hesaplama
    cost = - np.sum( Y * np.log(A) + (1-Y) * np.log(1 - A) ) / m 

    # GERİ YAYILMA (GRAD'ı BULMAK İÇİN)

    dw = (np.dot(X,(A-Y).T))/m
    db = np.sum(A-Y)/m

    grads = {"dw": dw,
             "db": db}

    return grads, cost

💫 Gradyan İnişi Gradient Descent (Optimizasyon)

def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
    """
    gradient descent algoritması çalıştırarak w ve b'yi optimize eder

    Argümanlar:
    w -- ağırlıklar, (num_px * num_px * 3, 1) boyutunda bir Numpy dizisi
    b -- önyargı (bias), bir skalerdir
    X -- (num_px * num_px * 3, kayıt sayısı) boyutunda veriler
    Y -- doğru etiket vektörü (kedi değilse 0, kediyse 1), (1, örnek sayısı) boyutunda
    num_iterations -- optimizasyon döngüsünün iterasyon sayısı
    learning_rate -- gradient descent'in öğrenme hızı
    print_cost -- True ise kaybı her 100 adım yazdırır

    Dönüş değeri:
    params -- ağırlıkları ve bias'ı içeren bir dictionary
    grads -- cost fonksiyonuna göre ağırlıkları ve bias'ı içeren bir dictionary
    costs -- optimizasyon esnasında bütün kayıp değerlerini içeren bir list, öğrenme eğrisini çizerken kullanılacak
    """

    costs = []

    for i in range(num_iterations):


        # Cost ve gradient'ı hesaplama
        grads, cost = propagate(w, b, X, Y)

        # türevleri grad'lardan elde etme 
        dw = grads["dw"]
        db = grads["db"]

        # kuralı güncelleme
        w = w - learning_rate*dw
        b = b - learning_rate*db

        # cost'ları kaydetme
        if i % 100 == 0:
            costs.append(cost)

        # kaybı her 100 iterasyonda yazdırır (opsiyonel)
        if print_cost and i % 100 == 0:
            print ("Cost after iteration %i: %f" %(i, cost))

    params = {"w": w,
              "b": b}

    grads = {"dw": dw,
             "db": db}

    return params, grads, costs

🕸 Basit Bir NN Temel Kod Parçları

2 katmanlı ağın fonksiyonları

Giriş katmanı, 1 gizli katman ve çıkış katmanı

🚀 Parametreleri Başlatma Initialization

def initialize_parameters(n_x, n_h, n_y):
    """
    Argümanlar:
    n_x -- giriş katmanının boyutu
    n_h -- gizli katmanın boyutu
    n_y -- çıkış katmanının boyutu

    Dönüş değeri:
    params -- parametreleri içeren bir:
                    W1 -- (n_h, n_x) boyutundaki ağırlıklar matrisi
                    b1 -- (n_h, 1) boyutundaki bias vektörü
                    W2 -- (n_y, n_h) boyutundaki ağırlıklar matrisi
                    b2 -- (n_y, 1) boyutundaki bias vektörü
    """
    # değerleri küçültmek için 0.01 ile çarpma
    W1 = np.random.randn(n_h,n_x) * 0.01
    b1 = np.zeros((n_h,1))
    W2 = np.random.randn(n_y,n_h) * 0.01
    b2 = np.zeros((n_y,1))

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}

    return parameters

⏩ İleri Yayılma

def forward_propagation(X, parameters):
    """
    Argümanlar:
    X -- (n_x, m) boyutundaki giriş verileri
    parameters -- parametreleri içeren dictionary (başlatma fonksiyonunun çıkış değeri)

    Dönüş değeri:
    A2 -- ikinci aktivasyonun sigmoid çıkışı
    cache -- "Z1", "A1", "Z2" and "A2" değerlerini içeren dictionary
    """

    # parameters'den parametreleri elde etme
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']

    Z1 = np.dot(W1, X) + b1
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)

    cache = {"Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2}

    return A2, cache

🚩 Maliyet Fonksiyonu Cost

def compute_cost(A2, Y):
    """
    Formülde verilen cross-entropy maliyetini hesaplar

    Argümanlar:
    A2 -- ikinci aktivasyonun sigmoid çıkışı, (1, örnek sayısı) boyutunda
    Y -- "true" etiket vektörü (1, örnek sayısı) boyutunda  

    Dönüş değeri:
    cost -- formülde verilen cross-entropy maliyeti

    """

    # örnek sayısı
    m = Y.shape[1] 

    # cross-entropy maliyetini hesaplama
    logprobs = np.multiply(np.log(A2), Y) + (1 - Y) * np.log(1 - A2)
    cost = - np.sum(logprobs) / m
    cost = float(np.squeeze(cost))  

    return cost

⏪ Geri Yayılma

def backward_propagation(parameters, cache, X, Y):
    """
    Daha önce verilen talimatları kullanarak geriye doğru yayılımı uygular

    Argümanlar:
    parameters -- parametrelerimizi içeren dictionary 
    cache -- "Z1", "A1", "Z2" and "A2" değerlerini içeren dictionary
    X -- (2, örnek sayısı) boyutundaki giriş verileri
    Y -- "true" etiket vektörü, (1, örnek sayısı) boyutunda

    Dönüş değeri:
    grads -- farklı parametrelere göre gradyanları içeren dictionary
    """
    m = X.shape[1]

    # parameters'dan W1 ve W2'yi elde etme
    W1 = parameters['W1']
    W2 = parameters['W2']

    # cache'den A1 ve A2'yi elde etme
    A1 = cache['A1']
    A2 = cache['A2']

    # Geri yayılma: calculating dW1, db1, dW2, db2 hesaplama 
    dZ2 = A2 - Y
    dW2 = np.dot(dZ2, A1.T) / m
    db2 = np.sum(dZ2, axis = 1, keepdims = True) / m
    dZ1 = np.dot(W2.T, dZ2) * (1 - A1 ** 2)
    dW1 = np.dot(dZ1, X.T) / m
    db1 = np.sum(dZ1, axis = 1, keepdims = True) / m

    grads = {"dW1": dW1,
             "db1": db1,
             "dW2": dW2,
             "db2": db2}

    return grads

🔃 Parametreleri Güncelleme

def update_parameters(parameters, grads, learning_rate = 1.2):
    """
    Daha önce verilen gradient descent güncelleme kuralını kullanarak parametreleri günceller

    Argümanlar:
    parameters -- parametrelerimizi içeren dictionary 
    grads -- gradyanlarımızı içeren dictionary 

    Dönüş değeri:
    parameters -- güncellenmiş parametreleri içeren dictionary 
    """
    # "parameters"'dan parametreleri elde etme
    W1 = parameters['W1']
    b1 = parameters['b1']
    W2 = parameters['W2']
    b2 = parameters['b2']

    # "grads"dan gradyanları elde etme
    dW1 = grads['dW1']
    db1 = grads['db1']
    dW2 = grads['dW2']
    db2 = grads['db2']

    # Kuralı her parametre için güncelleme
    W1 = W1 - learning_rate * dW1
    b1 = b1 - learning_rate * db1
    W2 = W2 - learning_rate * dW2
    b2 = b2 - learning_rate * db2

    parameters = {"W1": W1,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}

    return parameters

🌞 Yazının Aslı

• Burada 🐾

🔢 LeNet-5

LeNet-5 çok basit bir ağdır - Modern standartlara göre -. Sadece 7 katmanı vardır

• bunların arasında 3 konvolüsyon katmanı vardır (C1, C3 and C5)

• 2 sub-sampling (sıkıştırma) katmanları (S2 and S4)

• 1 tam bağlanmış katman (F6)

• Çıkış katmanı

👀 Ağın Görselleştirilmesi

🙌 Ağın Özeti

🛸 AlexNet

• LeNet-5' çok benziyor

• Katman başına daha fazla filtresi vardır

• tanh yerine ReLU kullanıyor

• Momentumlu Gradyan İnişi

• Düzenlileştirme yerine sönümleme (dropout) kullanıyor

👀 Ağın Görselleştirilmesi

🔎 Daha Ayrınıtılı

🙌 Ağın Özeti

🌱 VGG-16

👀 Ağın Görselleştirilmesi

🙌 Ağın Özeti

🔎 Daha Ayrıntılı

😐 Olumsuz Yanları

• Eğitilmesi aşırı yavaş (138 milyon parametresi var 🙄)

👩‍🔧 İmplementasyon

🌞 Yazının Aslı

🧐 Daha Fazla Oku

Önemli Terimler

🙌 Dolgulama (Padding)

Resme n+2 x n+2 olacak şekilde görüntüye bir veya daha fazla kenar ekleyerek ve konvolüsyondan sonra görüntünün orijinal boyutu olan n x n resimle sonuçlanır.

p = eklenen sınır sayısı

For convention: 0 ile doldurulur

🤔 Ne kadar dolgulanmalı?

Daha iyi anlaşılması için iki kavramımız olduğunu varsayalım:

🕵️‍♀️ Normal Konvolüsyon (Valid Convolution)

Dolgulama yok demektir, yani:

n x n * f x f ➡ n-f+1 x n-f+1

🥽 Dolgulamalı Konvolüsyon (Same Convolution)

Çıktı boyutunun, girdi boyutuyla aynı olmasını sağlayacak kadar dolgulanır

Yani biz istiyoruz ki 🧐:

n+2p-f+1 = n

Bundan dolayı:

p = (f-1)/2

Kabul: f tek sayı olarak seçilir 👩‍🚀

👀 Görselleştirme

🔢 Adımlı Konvolüsyon (Strided Convolution)

Konvolüsyonların başka bir yaklaşımı, bölgelere belirli bir s (adım sayısı) değerine göre filtre uygulayarak çıktıyı hesaplıyoruz.

👀 Görselleştirme

🤗 Genellemek İçin

Bir n x n'lik görüntü ve f x f'lik filtre için, p dolgulama miktarı ve s adım boyutu miktarı ile; çıkış görüntünün boyutu aşağıdaki formülle hesaplanabilir

🚀 Hacim Üzerine Konvolüsyon

RGB görüntüsü üzerine konvolüsyon işlemini uygulamak için; örneğin, 10x10 piksel RGB görüntüsünde, teknik olarak görüntünün boyutu 10x10x3'tür, bu nedenle örneğin 3x3x3'lük veya fxfx3'lük filtre uygulayabiliriz 🤳

Filtreler özel bir renk kanalına uygulanabilir 🎨

👀 Görselleştirme

🤸‍♀️ Birden Fazla Filtre

🎨 CNN'lerin Katman Türleri

👩‍🏫 Genellikle insanlar bir NN'deki katman sayısını bildirdiğinde, yalnızca ağırlıkları ve parametreleri olan katman sayısını söylerler

Kabul: CONV1 + POOL1 = LAYER1

🤔 Neden Konvolüsyonları Kullanalım?

Ayarlanacak parametreleri düşürdüklerinden dolayı daha iyi performans 💫

🌞 Yazının Aslı

🧐 Referanslar

🔄 Artıklı Ağlar (Residual Networks)

🙄 Problem

Bir sinir ağı eğitiminin her iterasyon sırasında, tüm ağırlıklar, mevcut ağırlığa göre hata fonksiyonunun kısmi türeviyle orantılı bir güncelleme alır. Eğer gradyan çok küçükse, ağırlıklar etkili bir şekilde değişmeyecek ve sinir ağını ileri eğitimden tamamen durdurabilir 🙄😪. Bu olaya Kaybolan Eğim (vanishing gradients) denir 🙁

Basitçe 😅: Çok yavaş gradiyan inişi nedeniyle verilerin derin sinir ağının katmanları arasında kaybolduğunu söyleyebiliriz

ResNet'in ana fikri, aşağıdaki gibi bir veya daha fazla katmanı atlayan identity shortcut connection sunmaktır.

🙌 Düz Ağlar vs ResNet'ler

👀 Görselleştirme

🤗 Avantajlar

• Bloklardan birinin identitiy fonksiyonunu öğrenmesi kolay

• Performansa zarar vermeden daha derine gidebilir

  • Düz NN'lerde, Kaybolan ve Patlayan Gradyanlar problemleri nedeniyle, ağın performansı derinleştikçe azalmaktadır.

1️⃣ Bire Bir Konvolüsyon (One By One Convolutions)

Propblem (Yada motivasyon 🤔)

Sıkıştırma ve çeşitli evrişim uygulayarak girişlerin boyutunu azaltabiliriz, bu filtreler girişin görüntüsünün yüksekliğini ve genişliğini azaltabilir; peki renk kuralları ne oluyor? 🌈, başka bir deyişle derinliği ne oluyor?

🤸‍♀️ Çözüm

Bir CNN çıktısının derinliğinin girişte uyguladığımız filtre sayısına eşit olduğunu biliyoruz;

Yukarıdaki örnekte 2 filtre uyguladık, böylece çıkış derinliği 2

CNN'lerimizi geliştirmek için bu bilgiyi nasıl kullanabiliriz? 🙄

🌞 Yazının Aslı

🧐 Daha Fazla Oku