mnist for experts

[Bilal Abdurrehim Şen]

Sess = tf.InteractiveSession()
İnteractive session proogrammı çok daha esnek yapıyor. Bu oturum(session) sayesinde modelde istediğiniz yeri çalıştırabiliriz.
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
Weight fonksiyonunda tf kütüphanesindeki tf.truncated_normal fonksiyonu kesilmiş normak dağılımlardan rastgele çıktılar verir. Argümanlardaki shape dizinin boyutunu belirler. Stddev ise kesikli normal dağılımın standart sapmasını belirler. Üretilen dizi initial değişkeninke tutulur ve değişken olarak döndürülür.

def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
tf.constant() fonksiyonu sabit tanımlar. Boyut olarak alınan shape tf.constanta parametre gönderilir. Bu dizinin boyutunu belirler. 0.1 ise dizinin elemanlarının değerleridir. İnitial değişkeninde tutulur ve değişken olarak döndürülür.

CNN ile yapacağımız bu modelde birçok ağırlık ve biasa ihtiyaç duyacağımız için bu işi kolaylıkla yapalım diye ağırlık ve biaslar için birer fonksiyon tanımladık. Bu yaptığımız işlem gürültüyü düşük tutmak için yapıldı.

def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

Konvolizasyon resimleri küçültmek için yapılan işlemdir. Bu sayede istenen nesnelere ulaşılır. tf.nn.conv2d fonksiyonu 2 boyutlu resimlere 4 boyutlu tensorler ve filtreci tensörlerle konvolizasyon işlemi uygular. X girdi tensorudur. W filtrecidir. X ile W’nin türler aynı olmalıdır. Stride 4 boyutlu dizi oluyor. Parametredeki dizinin ellemanları integer olmalıdır. Padding iki değer alabilir. ‘SAME’,’VALID’ hangi padding algoritmasının kullanılacağına karar veriliyor.

def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')

tf.nn.max_pool() fonksiyonu girdi üzerinde max pooling işlemini yapar. Buradaki x, 4 boyultlu bir tensördür. Türü float32’dir ([batch, height, width, channels])
ilk katmanı oluşturuyoruz:
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

ilk katmanın ağırlık ve bias değişkenlerini tanımladık. 5x5 parçlaraının 32 özelliği hesaplanacak. ([5, 5, 1, 32]) dizisi ağırlığın boyutaları olacak. İlk 2 eleman parçaların boyutları, bir sonraki eleman girişin kanal sayısı, son eleman ise çıkış kanlların sayısıdır.

x_image = tf.reshape(x, [-1,28,28,1])

Katmanın uygulanması için x girdisinin yeniden boyutlandırılması gerek ( 4 boyutlu olması gerek.). bunun için reshape fonksiyonu kullanılır. Dizinin 2. Ve 3. Elemanları girdi olarak verilen fotoğrafın boyutları son eleman ise renk kanalı sayısıdır.
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

yukarıdaki işlemlerde önce konvolizasyon daha sonra pooling işlemleri yapılıyor. conv2d(x_image, W_conv1) ile yukarıdaki conv2d fonksiyonuna yeniden boyutlandırılan x_image ile ağırlık fonksiyonu gönderiliyor daha sonra bias ile toplanıyor. Fotoğrafın özellikleri katmanların aktivasyonundan alınır. tf.nn.relu() fonksiyonu aktivasyonu hesaplar. İlk parametreye fonksiyona özellikler gönderilir.

İkinci katmanı tanımlıyoruz:
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

ilk katmanda 32 özellik hesaplanmıştı. Şimdi ise 64 özellik aktivasyon fonksiyonundan elde edildi.
Şimdi büyük katman tanımlanıyor(Densely Connected Layer):
W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7764])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
Bu katmanda fotoğrafın boyutları 7x7’ye düştü.
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

Yukarıdaki işlemde Readout katmanına geçilmeden önce uyum gösterme engellensin diye dropout fonksiyonu kullanıldı.

Readout katmanı tanımlanıyor:
Son olarak bu katmanda tahmin mekanizması ile sayıların ne olduğu tahmin ediliyor.
tf.nn.softmax() fonksiyonu tahmin işlemini yapıyor.

W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])

y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv), reduction_indices=[1]))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
Bu modelde optimizasyon algoritması olarak AdamOptimizer seçildi.,

correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

sess.run(tf.initialize_all_variables())
for i in range(20000):
batch = mnist.train.next_batch(50)
if i%100 == 0:
train_accuracy = accuracy.eval(feed_dict={
x:batch[0], y_: batch[1], keep_prob: 1.0})
print("step %d, training accuracy %g"%(i, train_accuracy))
train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

print("test accuracy %g"%accuracy.eval(feed_dict={
x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))