Bu öğretici bir şeyler yapmak isteyen ve nereden, nasıl başlayacağını bilememiş, programlama bilgisi olan, derin öğrenme meraklıları için hazırlanmıştır. Başlamadan önce Hesaplamalı Çizge‘nin ne olduğunu öğrenmelisiniz. TensorFlow bu veri akış çizgelerini kullanarak sayısal hesaplamalar yapmayı sağlar.

Resmi tanımlamalar yapmadan önce TensorFlow’un özünü bir anlayalım. Bu öğreticide Jupyter kullanacağız.  (Jupyter/IPython Notebook Quick Start Guide) 

Kullanılan NoteBook’a Veri Bilimcisi GitHub repository’sinden erisilebilirsiniz. 

TensorFlow Nasıl Çalışır?

TensorFlow’un program kodunu CPU’lar ve GPU’lar gibi farklı cihazlarda yürütebilmesinin nedeni onun özel yapısından kaynaklanır:

  • TensorFlow hesaplamaları, operasyonlar(ops) içeren Çizgeler(Graphs) olarak tanımlar.
  • Bu işlemleri kullanarak hesaplamalar yapmak için, Grafiği Oturum(Session) Olarak Başlatmalıyız.
  • Oturum, grafiklere dönüştürülen işlemleri bir GPU veya CPU gibi yürütmek istediğiniz cihaza aktarır.

Hesaplamalı Çizge Örneği

Aşağıda verilen denklemi inceleyelim.

  • Denklem: E = (A + B) * (B + 1)

Bu Denklemi hesaplamalı çizgeye dökebilmek için daha küçük parçalara ayırdık:

  • C = A + B
  • D = B + 1
  • E = C * D

Yukarıdaki denklemi hesaplamalı çizge şeklinde gösterirsek:

cizge

Şimdi tensorflow’u içe aktaralım:

import tensorflow as tf

Çizgeyi Oluşturalım

Daha önce söylediğimiz gibi TensorFlow hesaplamalı çizge olarak çalışır. İlk çizgemizi oluşturalım.

İlk çizgemizi oluşturmak için herhangi bir bilgi girişi gerektirmeyen source operations ‘i kullanacağız. Bu kaynak işlemleri veya source ops, bilgilerini hesaplamaları yürütecek diğer operasyonlara iletir.

Sayılarımızı tanımlayacak iki kaynak işlemi oluşturmak için iki tane sabit tanımlayacağız:

a = tf.constant([2], name="a")
b = tf.constant([3], name="b")
Bundan sonra, bu değişkenler üzerinde bir işlem yapalım. tf.add() fonksiyonu iki elemanı toplar. (ayrıca c = a + b kullanabilirsiniz).
c = tf.add(a,b, name="c")
# veya
# c = a + b 
Sonra TensorFlow kodumuzu çalıştırmak için bir oturum başlatması gerekiyor. Oturumlar, bir bakıma TensorFlow içinde bir grafik oluşturmak için bir bağlamdır. Oturumumuzu tanımlayalım:
session = tf.Session()
Az önce tanımladığımız ‘c’ işleminden sonucumuzu almak için oturumu çalıştıralım:
result = session.run(c)
print "Sonuc : " , result
Sonuc : [5]
Kullandığımız kaynakları serbest bırakmak için oturumu kapatmalıyız.
session.close()

Her seferinde oturumları kapatmak ile uğraşmamak için onları bir with bloğu içinde tanımlayabiliriz, böylece with bloğunu çalıştırdıktan sonra oturum otomatik olarak kapanacaktır:

with tf.Session() as session:
result = session.run(c)
print "Sonuc : " , result
Sonuc : [5]

Basit bir sonuca ulaşmak için 2 sabiti topladığımız bu aptalca örnek bile TensorFlow’un temelini tanımlamaktadır. Köşenizi tanımlayın (bu durumda sabitlerimiz), düğümleri ekleyin (işlemler, tf.add gibi) ve bir çizge oluşturmak için bir oturum başlatın her şey bu kadar 🙂

TensorBoard

Devam etmeden önce TensorBoard’dan bahsedelim.

TensorBoard: Öğrenmeyi Görselleştirmek
TensorFlow’u kullanacağınız hesaplamalar – büyük bir derin sinir ağı eğitmek gibi – karmaşık ve kafa karıştırıcı olabilir. TensorFlow programlarını anlamayı, hata ayıklamayı ve optimize etmeyi kolaylaştırmak için, TensorBoard adı verilen bir görselleştirme araçları paketi bulunmaktadır. TensorBoard’u TensorFlow grafiğinizi görselleştirmeye yarar. Bir önceki örnek üzerinde deneyelim:

with tf.Session() as session:
result = session.run(c)
print "Sonuc : " , result
writer = tf.summary.FileWriter('./logs', session.graph)

writer.close()
Sonuc : [5]

Aşağıdaki kodu çalıştırabilir veya terminalde çalıştırabilirsiniz. Terminalde çalıştırılması tavsiye edilir.
$ tensorboard –logdir=/path/logs

# import os # os.system("tensorboard --logdir=logs --port 6006")

Karşınıza şu ekran çıkacaktır:

ekran1

Graphs sekmesine gidildiğinde işlemimizin görseline ulaşabiliriz:

ekran2

Hesaplamalı Çizge Örneği

Hesaplamalı çizge örneğine devam edelim. Her işlem için yeni bir port açmak yerine çizgemizi default olarak ayarlayacağız, böyle :6006 portunu kullanacağız sadece. İlk olarak çizgemizi oluşturalım:

graph = tf.Graph() 

Şimdi A ve B değerlerini birer yer tutucu olarak tanımlayacağız. Bu kısaca bir önceki örnekte olduğu gibi sabit değerler tanımlamak yerine, oturumumuzu başlatırken A ve B’ye istediğimiz sayıları vermek istiyoruz. Bir ile toplama işlemindeki 1 sabit olduğu için onu sabit tanımlayacağız. Operasyonlarımız ise toplama ve çarpma, şu şekilde olacak:

with graph.as_default():
 A = tf.placeholder(tf.float32, name="A")
 B = tf.placeholder(tf.float32, name="B")
 bir = tf.constant(1.0, dtype=tf.float32, name="1")
 C = tf.add(A, B, name="C")
 D = tf.add(B, bir, name="D")
 E = tf.multiply(C, D, name="E")

Şimdi oturumumuzu başlatalım, A’ya 2 değerini ve B’ye 1 değerini vererek E denklemini hesaplayalım.

with tf.Session(graph=graph) as session:
 sonuc = (session.run(E, {A: 2, B: 1}))
 print "Sonuc : ", sonuc
 writer = tf.summary.FileWriter('./logs2', session.graph)
writer.close()
Sonuc : 6.0

TensorBoard ile hesaplamamızın görseli aşağıdaki gibi olacaktır:

ekran3

Toplama ve Çıkarma İşlemlerini aşağıdaki gibi de tanımlayabiliriz:

with graph.as_default():
A = tf.placeholder(tf.float32, name="A")
B = tf.placeholder(tf.float32, name="B")
bir = tf.constant(1.0, dtype=tf.float32, name="1")
C = A + B
D = B + 1
E = C * D

Oturumumuzu aynı şekilde başlattığımızda görselimiz şu şeklide olacaktır:

ekran4

Tensor’un Anlamı Nedir?

TensorFlow’da tüm veriler hesaplama çizgesinde operasyonlar arasından Tensor formunda geçirilir, TensorFlow ismi buradan gelir.

Tensorlerin çağdaş anlamı çok boyutlu dizilerdir.

Boyut Fiziksel Gösterimi Matematiksel Kod
Sıfır Nokta Skalar (Tek Sayı) [ 1 ]
Bir Çizgi Vektör (Sayı Dizisi) [ 1,2,3,4,… ]
İki Yüzey Matriks (Sayı Tablosu) [ [1,2,3,4,…], [1,2,3,4,…], [1,2,3,4,…],… ]
Üç Hacim Tensor (Sayı Kübü) [ [[1,2,…], [1,2,…], [1,2,…],…], [[1,2,…], [1,2,…], [1,2,…],…], [[1,2,…], [1,2,…], [1,2,…] ,…]… ]

Çok Boyutlu Dizilerin TensorFlow’da Gösterimi

Scalar = tf.constant([2])
Vector = tf.constant([5,6,2])
Matrix = tf.constant([[1,2,3],[2,3,4],[3,4,5]])
Tensor = tf.constant( [ [[1,2,3],[2,3,4],[3,4,5]] , [[4,5,6],[5,6,7],[6,7,8]] , [[7,8,9],[8,9,10],[9,10,11]] ] )
with tf.Session() as session:
result = session.run(Scalar)
print "Scalar (1 entry):\n %s \n" % result
result = session.run(Vector)
print "Vector (3 entries) :\n %s \n" % result
result = session.run(Matrix)
print "Matrix (3x3 entries):\n %s \n" % result
result = session.run(Tensor)
print "Tensor (3x3x3 entries) :\n %s \n" % result
Scalar (1 entry):
[2]Vector (3 entries) :
[5 6 2]Matrix (3×3 entries):
[[1 2 3]
[2 3 4]
[3 4 5]]Tensor (3x3x3 entries) :
[[[ 1 2 3]
[ 2 3 4]
[ 3 4 5]][[ 4 5 6]
[ 5 6 7]
[ 6 7 8]][[ 7 8 9]
[ 8 9 10]
[ 9 10 11]]]

Tensor’ler ile Basit İşlemler

Şimdi de tensorleri kullanarak bazı basit operasyonlara bakalım:


matris_1 = tf.constant([[1,2,3],[2,3,4],[3,4,5]])
matris_2 = tf.constant([[2,2,2],[2,2,2],[2,2,2]])

toplama = tf.add(matris_1, matris_2)
diger_toplama = matris_1 + matris_2

with tf.Session() as session:
 result = session.run(toplama)
 print "Tensorflow Fonksiyonu :"
 print(result)
 result = session.run(diger_toplama)
 print "Direkt Toplama Islemi :"
 print(result)
Tensorflow Fonksiyonu :
[[3 4 5]
[4 5 6]
[5 6 7]]
Direkt Toplama Islemi :
[[3 4 5]
[4 5 6]
[5 6 7]]
matris_1 = tf.constant([[2,3],[3,4]])
matris_2 = tf.constant([[2,3],[3,4]])

carpma = tf.matmul(Matrix_one,matris_2)

with tf.Session() as session:
 result = session.run(carpma)
 print "Tensorflow Fonksiyonu :"
 print(result)

Tensorflow Fonksiyonu :
[[13 18]
[18 25]]
Bazı Operasyonlar
islemler.png

Değişkenler

Variables

Değişkenleri tanımlamak için tf.variable () komutu kullanılır. Bir hesaplama grafiğinde değişkenleri kullanabilmek için onları bir oturumda çalıştırmadan önce başlatmanız gerekir. Bu, tf.global_variables_initializer () çalıştırılarak yapılır.

Bir değişkenin değerini güncellemek için, yalnızca değişkene bir değer atayan bir atama işlemi çalıştırırız:

durum = tf.Variable(0)

İlk önce, tek seferde bir birimi artıran basit bir sayaç oluşturalım:


bir = tf.constant(1)
yeni_deger = tf.add(durum, bir)
yenile = tf.assign(durum, yeni_deger)

Değişkenler, grafiği başlattıktan sonra bir başlatma işlemi çalıştırarak başlatılmalıdır. İlk önce başlatma işlemini grafiklere eklemek zorundayız:


init_op = tf.global_variables_initializer()

Daha sonra, grafiği çalıştırmak için bir oturum başlatırız, önce değişkenleri başlatıp, ardından durum değişkeninin başlangıç değerini ekrana bastıralım ve sonra her durumdan sonra durum değişkeni güncelleme ve sonucu yazdırma işlemini çalıştıralım:

 

with tf.Session() as session:
  session.run(init_op)
  print(session.run(durum))
  for _ in range(3):
    session.run(yenile)
    print(session.run(durum))

0
1
2
3

Yer Tutucular

Placeholders

Bir modelin dışından bir TensorFlow modeline veri beslemek isterseniz yer tutucu kullanmanız gerekir.

Yer tutucuları, modelinizde verileri iletmek için “delikler” gibi görebilirsiniz. tf.placeholder (veri türü), burada veri türü tamsayı (8, 16, 32, 64) bitleri ile birlikte veri türünü alır.

tablo.png

Bir yer tutucu oluşturalım:


a = tf.placeholder(tf.float32)

Ve basit bir çarpma işlemi tanımlayalım:


b=a*2

Şimdi oturumu tanımlamalı ve çalıştırmalıyız, ancak veriyi iletmek için modelde bir “delik” oluşturduğumuzdan, oturumu başlattığımızda veriyle bir argüman göndermek zorundayız yoksa hataya neden oluruz. Verileri modele geçirmek için oturumu fazladan bir argüman olan feed_dict ile çağırırız;


with tf.Session() as sess:
 result = sess.run(b,feed_dict={a:3.5})
 print result
 
7.0

TensorFlow’daki veriler çok boyutlu diziler şeklinde iletildiğinden, basit çarpma işleminin cevabını elde etmek için yer tutuculara her türden tensoru geçirebiliriz:

buyuk_tensor={a: [ [ [1,2,3],[4,5,6],[7,8,9],[10,11,12] ] , [ [13,14,15],[16,17,18],[19,20,21],[22,23,24] ] ] }

with tf.Session() as sess:
       result = sess.run(b,feed_dict=buyuk_tensor)
print result

[[[ 2. 4. 6.]
[ 8. 10. 12.]
[ 14. 16. 18.]
[ 20. 22. 24.]]

[[ 26. 28. 30.]
[ 32. 34. 36.]
[ 38. 40. 42.]
[ 44. 46. 48.]]]

Operasyonlar

Operations

Operasyonlar(işlemler), bir çizgede tensorler üzerindeki matematiksel işlemleri temsil eden düğümlerdir. Bu işlemler, toplama ve çıkarma tensorü veya belki bir aktivasyon fonksiyonu gibi herhangi bir operasyon türü olabilir. tf.matmultf.addtf.nn.sigmoid, TensorFlow’daki operasyonlardan bazılarıdır. Bir kaç örneğe bakalım:

 

a = tf.constant([5])
b = tf.constant([2])
c = tf.add(a,b)
d = tf.subtract(a,b)

with tf.Session() as session:
    result = session.run(c)
    print 'c =: %s' % result
    result = session.run(d)
    print 'd =: %s' % result

c =: [7]
d =: [3]

CS 20SI: Tensorflow for Deep Learning Research, Lecture Notes, Chip Huyen