Yapay Sinir Ağı Eğitimi

Bu yapay sinir ağı eğitiminde bir adım daha ileri gideceğiz ve Çok Katmanlı Perceptron adı verilen perceptronlar ağı hakkında tartışacağız.

Bu nöral ağ eğitiminde aşağıdaki konuları tartışacağız:

Tek Katmanlı Perceptron Sınırlamaları
Çok Katmanlı Perceptron (Yapay Sinir Ağı) Nedir?
Yapay Sinir Ağları Nasıl Çalışır?
Use-Case
Yapay sinir ağı eğitimi hakkındaki bu yazı, sonunda bir use-case içerecektir. Bu Use-case’i uygulamak için TensorFlow kullanıyor olacağız.

Şimdi, Tek katmanlı Perceptron’un sınırlamalarının neler olduğunu tartışarak başlayacağım.

Tek Katmanlı Perceptronun Sınırlamaları:

Eh, iki büyük sorun var:

Tek Katmanlı Perceptronlar, doğrusal olmayan ayrılabilir veri noktalarını sınıflandıramaz.
Çok katmanlı parametreleri içeren karmaşık problemler, Tek Katmanlı Perceptronlarla çözülemez.
Tek Katmanlı Perceptronlar, lineer olmayan ayrılabilir veri noktalarını sınıflandıramaz.
Bunu XOR kapısı örneğini alarak anlayalım. Aşağıdaki şemaya bakınız:

Burada, yüksek ve alçak noktaları tek bir düz çizgi ile ayıramazsınız. Ancak, onu iki düz çizgi ile ayırabiliriz. Aşağıdaki şemaya bakınız:

Çok katmanlı parametreleri içeren karmaşık problemler Tek Katmanlı Perceptronlarla çözülemez:
Burada da bir örnekle açıklayacağım.

Mesela, bir e-ticaret şirketi olarak, satışlarınızda bir düşüş fark ettiniz. Şimdi, satışları artırmak için ürünleri pazarlayacak bir pazarlama ekibi oluşturmaya çalışıyorsunuz.

Pazarlama ekibi, ürününüzü çeşitli yollarla pazarlayabilir:

Google Reklamları
Kişisel e-postalar
İlgili sitelerde satış ilanı
Referans programı
Bloglar vb. . .
Mevcut tüm faktörler ve seçenekler göz önüne alındığında, pazarlama ekibinin optimal ve etkin pazarlama yapmak için bir stratejiye karar vermesi gerekir, ancak bu görev, bir insanın analiz etmesi için çok karmaşıktır, çünkü parametrelerin sayısı oldukça yüksektir. Bu problem derin öğrenme kullanılarak çözülmelidir. Aşağıdaki şemaya bakınız:

Ürünlerini pazarlamak ya da çeşitli ürünler kullanmak için sadece bir araç kullanabilirler.

Her şekilde farklı avantajları ve dezavantajları olacak, bunlar gibi çeşitli faktörlere ve seçeneklere odaklanmak zorunda kalacaklar:

Gerçekleştirilecek satış sayısı farklı kategorik girdilere, alt kategorilerine ve parametrelerine bağlı olacaktır. Ancak, çok sayıda girdiden ve alt parametrelerinden hesaplamak sadece bir nöron(perceptron) ile mümkün değildir.

Bu sorunu çözmek için birden fazla nöronun kullanılmasının nedeni budur. Aşağıdaki şemaya bakınız:

Tüm bu nedenlerden dolayı, Tek Katmanlı Perceptron karmaşık doğrusal olmayan problemler için kullanılamaz.

Şimdi, bu yapay sinir ağı eğitiminde çok katmanlı algılayıcılara(Multi Layer Perceptron) odaklanacağım.

Çok Katmanlı Perceptron Nedir?

Bildiğiniz gibi, beynimiz milyonlarca nörondan oluşur, bu nedenle bir sinir ağı, sadece farklı yollarla bağlanan ve farklı aktivasyon fonksiyonlarında çalışan perceptronların bir bileşimidir.

Aşağıdaki şemaya bakınız:

Girdi Düğümleri: Giriş düğümleri dış dünyadan ağa bilgi sağlar ve birlikte “Giriş Katmanı” olarak adlandırılır. Giriş düğümlerinden hiçbirinde hesaplama yapılmaz – bunlar sadece gizli düğümlere bilgi aktarır.
Gizli Düğümler: Gizli düğümlerin dış dünyayla doğrudan bağlantısı yoktur(bundan dolayı “gizli” adı verilir.). Hesaplamalar yaparlar ve girdi düğümlerinden çıkış düğümlerine bilgi aktarırlar. Gizli düğümlerden oluşan bir koleksiyon “gizli katman” oluşturur. Bir ağ sadece tek bir giriş katmanına ve tek bir çıktı katmanına sahipken, sıfır veya çoklu gizli katmanlara sahip olabilir. Çok Katmanlı bir Perceptron’un bir veya daha fazla gizli katmanı vardır.
Çıktı Düğümleri: Çıktı düğümleri toplu olarak “Çıktı Katmanı” olarak adlandırılır ve bilgi işlemlerden ve ağdan dış dünyaya bilgi aktarımından sorumludur.
Evet, doğru tahmin ettiniz, bir yapay sinir ağının nasıl çalıştığını açıklamaya bir örnek vereceğim.

Bir futbol takımı verdiğimizi varsayalım, misal Chelsea. Veriler üç sütun içerir. Son sütun Chelsea’nin maçı kazanıp kazanmadığını veya kaybettiğini söyler. Diğer iki sütun ise, ilk yarıda gol atma ve ikinci yarıda sahip olma ile ilgilidir. Pozisyon oranı, takımın topa yüzde olarak sahip olduğu süre miktarıdır. Yani, bir takımın yarı yarıya (%50) sahip olduğu söylenirse, takımın 45 dakika içinde 22.5 dakika topa sahip olduğu anlamına gelir.

İlk Yarı Gol Atağı Sayısı	İkinci Yarı Topa Sahip Olma Oranı	Kazandı mı veya Kazanamadı mı?(1,0)
0	80%	1
0	35%	0
1	42%	1
2	20%	0
-1	75%	1

Nihai sonuç sütununda, Chelsea’nin maçı kazanıp kazanmadığını belirten iki değer 1 veya 0 olabilir. Örneğin, ilk yarıda ve bir sonraki yarıda Chelsea’nin %80 oranında bir topla oynama oranı varsa Chelsea’nin maçı kazanacağını görebiliriz.

Şimdi, ilk yarıdaki gol atağı 2 ise ve ikinci yarıda topla oynama oranı %32 ise Chelsea’nin maçı kazanıp kazanmayacağını tahmin edelim.

Bu, Çok Katmanlı bir Perceptron’un verilen örneklerden (eğitim verileri) öğrenebileceği ve yeni bir veri noktası verildiğinde bilinçli bir tahminde bulunabileceği bir ikili sınıflandırma problemidir. Çok Katmanlı bir Perceptronun bu ilişkileri nasıl öğrendiğini aşağıda göreceğiz.

Aşağıdaki şemaya bakınız:

İleri Yayılma:

Burada ileriye doğru ilerleyeceğiz, yani girişlerin ağırlıklı toplamını hesaplayacağız ve bias ekleyeceğiz. Çıktı katmanında Chelsea’nin kazanma veya kaybetme olasılığını elde etmek için softmax fonksiyonunu kullanacağız.

Diyagramı fark ederseniz, kazanma olasılığı 0,4 ve kaybedilme olasılığı 0,6’dır. Ancak, verilerimize göre, ilk yarıda 1 gol atağı olduysa ve ikinci yarı toplama oynama oranı %42 olduğunda Chelsea’nin kazanacağını biliyoruz. Ağımız yanlış tahmin yaptı.

Hatayı görüyorsak (ağ çıkışını hedefle karşılaştırmak) 0,6 ve -0,6’dır.

Geri Yayılım ve Ağırlık İyileştirme:

Çıkış düğümlerindeki toplam hatayı hesaplıyoruz ve bu hataları gradyanları hesaplamak için backpropagation kullanarak ağ üzerinden geri iletiyoruz. Ardından, çıkış katmanındaki hatayı azaltma amacıyla ağdaki tüm ağırlıkları ayarlamak için gradyan iniş gibi bir optimizasyon yöntemi kullanırız.

Gradyan iniş iyileştiricisinin nasıl çalıştığını size açıklayayım:

Adım – 1: Önce, hatayı hesaplıyoruz, aşağıdaki denklemi dikkate alınız:

Adım – 2: Elimizdeki hatayı temel alarak, ağırlıklardaki değişime göre hatanın değişme oranını hesaplayacaktır.

Adım – 3: Şimdi, ağırlıktaki bu değişime dayanarak, yeni ağırlık değerini hesaplayacağız.

Şimdi aynı örneği tekrar ağa girersek, ağ, tahminlerdeki hatayı en aza indirgemek için ağırlıklar ayarlanmış olduğundan, ağ öncekinden daha iyi performans göstermelidir. Aşağıdaki örneği ele alalım, Şekilde gösterildiği gibi, çıkış düğümlerindeki hatalar şimdi [0.6, -0.4] ile karşılaştırıldığında [0,2, -0,2] ‘ye düşmektedir. Bu, ağımızın ilk eğitim örneğimizi doğru şekilde sınıflandırmayı öğrendiği anlamına gelir.

Bu süreci, veri kümemizde yer alan diğer tüm eğitim örnekleriyle tekrarlıyoruz. Sonra ağımızın bu örnekleri öğrendiği söyleniyor.

Şimdi, girdiyi ağımıza besleyebilirim. İlk yarıda gol atağını 2 olarak alırsam ve ikinci yarıda topa sahip olma oranını %32 aldığımda, ağımız Chelsea’nin bu maçı kazanıp kazanmayacağını tahmin eder.

Şimdi bu yapay sinir ağı eğitiminde, bazılarını uygulamalı olarak göreceğiz. Çok katmanlı bir sinir ağını modellemek için TensorFlow kullanacağım.

Use-Case

Şimdi, ağımızı eğitmek için kullanacağımız veri kümesine bakalım. Veri kümesini buradan indirebilirsiniz.

İlk dört sütun özellikleridir ve son sütun etikettir.

Veriler, orijinal ve sahte banknot benzeri örneklerden alınan görüntülerden çıkarıldı. Son görüntüler 400 × 400 pikseldir. Nesne lensi ve incelenen nesne gri ölçeğine olan uzaklık nedeniyle, yaklaşık 660 dpi çözünürlükteki resimler elde edildi. Dalgacık dönüşümü aracı, görüntülerden elde edilen özellikleri ayıklamak için kullanıldı.

Bu use-case’i uygulamak için aşağıdaki akış diyagramını kullanacağız:

Şimdi kodlamaya başlayalım:

import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.utils import shuffle
from sklearn.model_selection import train_test_split

# Verisetini okuyalım:
def read_dataset():
    df = pd.read_csv("C:/Users/.../banknote.csv")
    # print(len(df.columns))
    X = df[df.columns[0:4]].values
    y = df[df.columns[4]]

    # Bağımlı değişkeni kodlayın.
    Y = one_hot_encode(y)
    print(X.shape)
    return (X, Y)


# Enkoder fonksiyonunu tanımlayın.
def one_hot_encode(labels):
    n_labels = len(labels)
    n_unique_labels = len(np.unique(labels))
    one_hot_encode = np.zeros((n_labels, n_unique_labels))
    one_hot_encode[np.arange(n_labels), labels] = 1
    return one_hot_encode


# Verisetini oku.
X, Y = read_dataset()

# Satırları karıştırmak için veri kümesini karıştırın.
X, Y = shuffle(X, Y, random_state=1)

# Veri kümesini eğitim ve test bölümüne dönüştürün.
train_x, test_x, train_y, test_y = train_test_split(X, Y, test_size=0.20, random_state=415)

# Eğitim ve test şeklini inceleyin.
print(train_x.shape)
print(train_y.shape)
print(test_x.shape)

# Tensörler ile çalışmak için önemli parametreleri ve değişkenleri tanımlayın.
learning_rate = 0.3
training_epochs = 100
cost_history = np.empty(shape=[1], dtype=float)
n_dim = X.shape[1]
print("n_dim", n_dim)
n_class = 2
model_path = "C:/Users/.../BankNotes"

# Her katman için gizli katmanların sayısını ve nöron sayısını tanımlayın.
n_hidden_1 = 4
n_hidden_2 = 4
n_hidden_3 = 4
n_hidden_4 = 4

x = tf.placeholder(tf.float32, [None, n_dim])
W = tf.Variable(tf.zeros([n_dim, n_class]))
b = tf.Variable(tf.zeros([n_class]))
y_ = tf.placeholder(tf.float32, [None, n_class])


# Modeli tanımlayın.
def multilayer_perceptron(x, weights, biases):

    # RELU aktivasyon fonksiyonları ile gizli katman
    layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])
    layer_1 = tf.nn.relu(layer_1)

    # Sigmoid akvitasyon fonksiyonları ile gizli katman
    layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])
    layer_2 = tf.nn.relu(layer_2)

    # Sigmoid aktivasyon fonksiyonları ile gizli katman
    layer_3 = tf.add(tf.matmul(layer_2, weights['h3']), biases['b3'])
    layer_3 = tf.nn.relu(layer_3)

    # Hidden layer with RELU activation
    layer_4 = tf.add(tf.matmul(layer_3, weights['h4']), biases['b4'])
    layer_4 = tf.nn.sigmoid(layer_4)

    # Lineer aktivasyonlu çıktı katmanı
    out_layer = tf.matmul(layer_4, weights['out']) + biases['out']
    return out_layer


# Her katman için ağırlıkları ve biasları tanımlayın.

weights = {
    'h1': tf.Variable(tf.truncated_normal([n_dim, n_hidden_1])),
    'h2': tf.Variable(tf.truncated_normal([n_hidden_1, n_hidden_2])),
    'h3': tf.Variable(tf.truncated_normal([n_hidden_2, n_hidden_3])),
    'h4': tf.Variable(tf.truncated_normal([n_hidden_3, n_hidden_4])),
    'out': tf.Variable(tf.truncated_normal([n_hidden_4, n_class]))
}
biases = {
    'b1': tf.Variable(tf.truncated_normal([n_hidden_1])),
    'b2': tf.Variable(tf.truncated_normal([n_hidden_2])),
    'b3': tf.Variable(tf.truncated_normal([n_hidden_3])),
    'b4': tf.Variable(tf.truncated_normal([n_hidden_4])),
    'out': tf.Variable(tf.truncated_normal([n_class]))
}

# Tüm değişkenleri başlatın.

init = tf.global_variables_initializer()

saver = tf.train.Saver()

# Modelinizi tanımlayın.
y = multilayer_perceptron(x, weights, biases)

# Maliyet fonksiyonunu ve optimize ediciyi tanımlayın.
cost_function = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y, labels=y_))
training_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost_function)

sess = tf.Session()
sess.run(init)

# Her dönem için maliyeti ve doğruluğu hesaplayın.
mse_history = []
accuracy_history = []

for epoch in range(training_epochs):
    sess.run(training_step, feed_dict={x: train_x, y_: train_y})
    cost = sess.run(cost_function, feed_dict={x: train_x, y_: train_y})
    cost_history = np.append(cost_history, cost)
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    # print("Accuracy: ", (sess.run(accuracy, feed_dict={x: test_x, y_: test_y})))
    pred_y = sess.run(y, feed_dict={x: test_x})
    mse = tf.reduce_mean(tf.square(pred_y - test_y))
    mse_ = sess.run(mse)
    mse_history.append(mse_)
    accuracy = (sess.run(accuracy, feed_dict={x: train_x, y_: train_y}))
    accuracy_history.append(accuracy)

    print('epoch : ', epoch, ' - ', 'cost: ', cost, " - MSE: ", mse_, "- Train Accuracy: ", accuracy)

save_path = saver.save(sess, model_path)
print("Model dosyaya kaydedildi: %s" % save_path)

# Doğruluk oranı grafiğini çizdirin.
plt.plot(accuracy_history)
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.show()

# Son doğruluğu yazdırın.

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print("Test Accuracy: ", (sess.run(accuracy, feed_dict={x: test_x, y_: test_y})))

# Son ortalama kare hatasını yazdırın.

pred_y = sess.run(y, feed_dict={x: test_x})
mse = tf.reduce_mean(tf.square(pred_y - test_y))
print("MSE: %.4f" % sess.run(mse))

Bu kodu çalıştırdıktan sonra aşağıdaki çıktıyı alacaksınız:

Kaynak: https://www.edureka.co/blog/neural-network-tutorial/