snbilall / decoders Goto Github PK

Toruch Kütüphanesi
Derin öğrenme algoritmalarını bilgisayar diline çevirmek için birçok yazılım kütüphanesi bulunmaktadır . Torch, en çok kullanılan kütüphanelerden birisidir. Torch, açık kaynak kodlu makine öğrenme kütüphanesidir. Torch makine öğrenme algoritmaları için kapsamlı destek sunan bilimsel hesaplama yapısıdır. Kolay ve hızlı kodlama dili LuaJIT ve C/CUDA uygulaması temelini kullanan kolay ve verimli bir yapıya sahiptir
• güçlü bir N-boyutlu dizi (N-dimensional array)
• indeksleme, kesme, yer değiştirme vb. bir çok rutin
• LuaJIT(1) ile hayranlık oluşturan C arayüzü
• lineer cebir rutinleri
• sinir ağı ve enerji tabanlı modeller
• sayısal en iyileme rutinleri
• Hızlı ve etkili GPU desteği
• iOS, Android ve FPGA arka ucuna port ile gömülebilme

Torch işlemleri oldukça basitleştirirken bilimsel algoritmalarınızı hazırlamayı azami esneklik ve hızda yapmanızı amaçlamaktadır. Torch Lua topluluğunun hazırladıklarının yanısıra makine öğrenmesi, bilgisayarlı görü, sinyal işleme, paralel işlem, resim, video, ses ve ağ iletişimi gibi geniş ekosistem içindeki topluluk tarafından hazırlanmış paketler ile gelmektedir.
Torch’un kalbinde kompleks sinir ağı topolojisini uygulamada had safhada esnek, kullanımı kolay olan popüler sinir ağı ve en iyileme kütüphaneleri vardır. Sinir ağının isteğe bağlı grafiğini oluşturabilir ve CPU’lar ve GPU’lar arasında etkili bir şekilde paralel işlem yapabilirsiniz.
Torch sürekli geliştirilmektedir: hali hazırda Facebook, Google, Twitter, NYU, IDIAP, Purdue ile çeşitli firma ve araştırma laboratuarları tarafından kullanılmaktadır.Torch sinir ağları, optimizasyon, grafik model ve resim işleme paketlerine hakim derin öğrenmede sıkça kullanılan bir kütüphanedir. 2000li yıllardan itibaren aktif olarak kullanılmaktadır. Çeşitli versiyonları dahi çıkmıştır. Geniş kapsamlı öğrenmeyi amaç edinmiştir.
BSD lisansı ile yayınlanması ise diğer bir yönüdür. Bu sayede açık kaynak kodlu olmasının avantajlarından faydalanılabilir. Peki ya nedir BSD lisans?
BSD lisansın ne olduğundan önce şu kavramları inceleyelim:
Patent: Belirli süreyle ürünü üretme, kullanma ve satma hakkı.
Telif Hakkı: Kişinin ürün üzerindeki hakları.
Lisans: Telif hakkı olan kişinin haklarını koruyan belge yetkinliği
Açık kaynak kod deyince akla her ne kadar GPL (General Public License) gelse de bunun dışında da BSD, MOZİLA, MIT, IBMPL gibi çeşitli açık kaynak kodlu lisanslar da vardır. Biz bunların içinde bizimle alakalı olan BSD lisans üzerinde biraz durup asıl konumuz olan Torch Kütüphanesine tekrar döneceğiz.
BSD(Berkeley Software Distribution) ile GPL karşılaştıracak olursak:
BSD lisansı yazılım üzerine neredeyse hiç bir sınırlama getirmez. Peki BSD lisansı “neden hiç bir sınırlama getirmiyor?” gibi bir soru haklı olarak akla gelebilir. BSD lisansı hiçbir sınırlama getirmiyor; çünkü BSD lisansıyla üretilen yazılımlar, kamu fonlarından sağlanan parayla geliştiriliyor ve dolayısıyla yazılımın kendisiyle beraber kaynak kodları da kamuya ait oluyor. Yani isteyen herkes bu yazılımları istediği gibi kullanma hakkına sahip oluyor. GPL ile BSD’nin ayrıldığı en önemli nokta da burada ortaya çıkıyor. BSD lisansı sayesinde açık olarak dağıtılan yazılımın kodlarını kapatıp yazılım üzerinden para kazanabilirsiniz; ancak bu durum GPL’de tam tersidir. Microsoft’un Windows 2000’de FreeBSD’nin TCP/IP kodlarını alıp, bunları kapatması sıkça verilen bir örnektir.
Derin öğrenme algoritmalarını bilgisayar diline çevirmek için birçok yazılım kütüphanesi bulunmaktadır. Bu kütüphaneler algoritmaların uygulanmasına kolaylık sağlar. Torch, en çok kullanılan kütüphanelerden birisidir. Torch, açık kaynak kodlu makine öğrenme kütüphanesidir. Temeli Lua programlama diliyle oluşturulmuştur; bilimsel hesaplamalar ve makine öğrenme uygulamalarında yaygınca kullanılmaktadır. Derin öğrenme algoritmalarını hızlı betikleme dili sayesinde kolayca kodlamaya imkânı sağlar. Bünyesinde popüler yapay sinir ağlarının yapısını ve optimizasyon kütüphanelerini barındırır ve bu sayede makine öğrenme algoritmaların uygulamalarını kolaylaştırır. Torch, sadece Linux ve Mac Os X platformlarında kullanılmaktadır.

        Torch Yükleme

Torch yüklemek için terminale aşağıdaki komutlar girilir:

curl -sk https://raw.githubusercontent.com/torch/ezinstall/master/install-deps | bash
git clone https://github.com/torch/distro.git ~/torch –recursive
cd ~/torch; ./install.sh

Kullanılan işletim sistemi Ubuntu ise komutların başına “sudo” yazılması gerekmektedir. Yükleme bittikten sonra torch “Path” değerini atamak için aşağıdaki komut kullanılır.

source ~/.bashrc

Yükleme tamamlandıktan sonra torch yazılım kütüphanesini açmak için “th” komutu kullanılır. Torch uygulamasından çıkmak için ise “CTRL + C” komutu iki kez kullanılır. Torch dışında kullanılabilecek diğer kütüphaneler şunlardır:
• Theano
• Deeplearning4j
• ND4J
• NVIDIA cuDNN
• Convnetjs
• Gensim
• Caffe

(1)Lua en hızlısı(aşağıdaki linkten test edebilirsiniz ve herhangi bir script dili dahada hızlanmasını sağlayan jit teknolojisini desteklenmekte-scripti bayt koda çeviren teknoloji-LuaJIT) C tabanlı bir dildir.
Kaynaklar:
https://dctekkilic.wordpress.com/2015/05/18/derin-ogrenme-yazilim-kutuphaneleri-ve-torch/
http://www.derinogrenme.com/torch/
http://www.derinogrenme.com/torch/torch-baslangic-rehberi/

https://dashoff.wordpress.com/2009/09/19/gpl-bsd-lgpl-nedir/ (AÇIK KAYNAK KOD GPL-BSD)

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}))

tutorial
tensorflow'da mnist sınıflandırıcısı.
Öncelikle aşağıdaki kod parçaları yazılarak mnist dataları indirilir.
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

import tensorflow as tf
tf referansı ile tensorflow kütüphanesi çağrılır.
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
mnist dataları mnist değişkeninde tutulur.
sess = tf.InteractiveSession()
Sess referansı ile session işlemi
Model oluşturma işlemi
x = tf.placeholder(tf.float32, [None, 784])
placeholder burada girdi işlemi yapmak içindir. float32 tipindedir. İstediğimiz sayıda girdi işlemi yapabilme için 'none' yazıldı. 784 ise resimlerin boyutlarının çarpımı ile elde edilir. mnist resimlerinin boyutları 28*28 dir. çarpımlarıyla 784 elde edilir ve bu resim vektör haline getirilir.
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))
Ağırlıklar ve bias larda yukarıdaki gibi değişken tipinde tanımlanır. Ağırlık 2 boyutlu dizi şeklinde tanımlandı. Bias ise vektör şeklinde tanımlandı.

y = tf.nn.softmax(tf.matmul(x, W) + b)
Yukarıdaki satırda modelin uygulaması yapıldı. öncelikle Tensorflowda matris çarpma işlemi (tf.matmul()) ile ağırlıkla girdi (x) ile matris çarpma işlemi yapıldı ve daha sonra bias ile toplandı. elde ettiğimiz değer softmax regresyonu ile resimdeki sayının ne olduğu tahmin edildi.

y_ = tf.placeholder(tf.float32, [None, 10])
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
yukarıdaki kod parçalarında tasarlanan modelin kaybı (loss) bulunup minimize edildi. Modeldeki kayıp demek modelin ne kadar iyi veya ne kadar kötü olduğunun göstergesi demektir. bu oran ne kadar düşük olursa model o kadar iyidir. y_ placeholder da verilen girdilerin doğru sonuçları tutuldu. yukarıdaki işlemlerden geçerek cross_entropy değeri elde edildi. Bulunan bu kaybın minimize edilmesi için 0.5 oranı ile gradient descent algoritması kullanıldı

tf.initialize_all_variables().run()
tüm değişkenler initialize edildi.

for i in range(100):
batch_xs, batch_ys = mnist.train.next_batch(100)
train_step.run({x: batch_xs, y_: batch_ys})
datasette 100 resimin gerçeklemesi yapıldı.

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
yukarıdaki kod parçası tahminlerin doğru olup olmadığını kontrol ediyor. correct_prediction hesaplamasında tf.argmax(y,1) fonksiyonu tahmin edilen değerler arasındaki en büyüğünü döndürür. tf.argmax(y_,1) ise doğru olan değeri döndürür. tf.equal ise iki değerin eşit olup olmadığını bool tipinde döndürerek hesaplar.

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
yukarıdaki kod parçası ise float32 tipinde doğruluk oranını çıkarıyor. tf.reduce_mean() fonksiyonuna parametre olarak correct_prediction dizisi gönderilir ve bu fonksiyon true boollarının oranını bulur.

print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
yukarıdaki kod parçası ise doğruluk oranını ekrana basar.