TensorFlow Nedir? Nasıl Kullanılır?

Fatih Küçükkarakurt

Fatih Küçükkarakurt

20 min read

TensorFlow, makine öğrenimi ve derin öğrenme sistemlerini uygulamak için kullanılan, Google tarafından oluşturulmuş açık kaynaklı bir yazılım kitaplığıdır. TensorFlow, bir bilgisayarın karmaşık kalıpları otomatik olarak nasıl tespit edeceğini ve/veya mümkün olan en iyi kararları nasıl vereceğini öğrenmesine izin vermek için ortak bir zorluğu paylaşan bir dizi güçlü algoritma içerir.

Bu sistemler ile ilgileniyorsanız ve yazılım teknolojilerine meraklıysanız, Anatoliacode blog gönderilerini inceleyebilirsiniz.

İçerik

TensorFlow’a Giriş

TensorFlow, temelinde veri akışı programlaması için bir kitaplıktır. Matematiksel ifadelerin hesaplanmasını daha kolay ve daha performanslı hale getirmek için çeşitli optimizasyon tekniklerinden yararlanır.

TensorFlow’un temel özelliklerinden bazıları şunlardır:

  • Çok boyutlu diziler içeren matematiksel ifadelerle verimli bir şekilde çalışır.
  • Derin sinir ağları ve makine öğrenimi kavramları için iyi bir destektir.
  • Aynı kodun her iki mimaride de yürütülebildiği GPU/CPU hesaplama.
  • Makineler ve büyük veri kümeleri arasında yüksek hesaplama ölçeklenebilirliği.

Bu özellikler, TensorFlow’u üretim ölçeğinde makine zekası için mükemmel bir çerçeve haline getirir.

Bu TensorFlow makalesinde, TensorFlow’da basit ama güçlü makine öğrenimi yöntemlerini nasıl kullanabileceğinizi ve onunla oluşturulan modellerde hata ayıklama, görselleştirme ve ince ayar yapma için yardımcı kitaplıklarından bazılarını nasıl kullanabileceğinizi öğreneceksiniz.

TensorFlow’u Yükleme

Makalemizde, Python 2.7 ve Python 3.3+ ile çalışan TensorFlow Python API‘yi kullanacağız. GPU sürümü (Linux), Cuda Toolkit 7.0+ ve cuDNN v2 + gerektirir.

TensorFlow’u kurmak için Conda yönetim sistemini kullanacağız. Conda, bir makinedeki birden çok ortamı ayırmamıza olanak tanır. Conda’yı nasıl yükleyeceğiniz hakkında bilgi almak isterseniz bu linki kullanabilirsiniz.

Conda’yı kurduktan sonra TensorFlow kurulumu ve kullanımı için kullanacağımız ortamı oluşturabiliriz. Aşağıdaki komut, TensorFlow’u kullanmaya başladığımızda çok faydalı olan NumPy gibi bazı ek kitaplıklarla çalışma ortamımızı oluşturacaktır.

Vereceğimiz örneklerdeki Python sürümü 2.7‘dir.

conda create --name TensorflowEnv biopython

İşleri biraz daha kolaylaştırmak için buraya sadece NumPy yerine biopython kuruyoruz. Bu, NumPy ve ihtiyaç duyacağımız diğer birkaç paketi içerir. Paketlere ihtiyaç duyduğunuzda conda install veya pip install komutlarını kullanarak kurabilirsiniz.

Aşağıdaki komut, oluşturulan Conda ortamını etkinleştirecektir. Global veya başka ortamlarda kurulan paketlerle karıştırmadan, içinde kurulu paketleri kullanabileceğiz.

source activate TensorFlowEnv

Pip kurulum aracı, Conda ortamının standart bir parçasıdır. Bunu TensorFlow kütüphanesini kurmak için kullanacağız. Bunu yapmadan önce, aşağıdaki komutu kullanarak pip’i en son sürüme güncellemek iyi olacaktır:

pip install --upgrade pip

Aşağıdaki komutu çalıştırarak TensorFlow’u kurmaya hazır hale gelebiliriz:

pip install tensorflow

TensorFlow’un indirilmesi ve oluşturulması birkaç dakika sürebilir.

TensorFlow Veri Akış Grafikleri

TensorFlow’da hesaplama, veri akış grafikleri kullanılarak açıklanır. Grafiğin her bir düğümü, bir matematiksel işlemin (toplama, bölme veya çarpma gibi) bir örneğini temsil eder ve her kenar, işlemlerin gerçekleştirildiği çok boyutlu bir veri kümesidir (tensor).

TensorFlow hesaplama grafikleriyle çalıştığı için, her düğümün, her işlemin sıfır veya daha fazla girdiye ve sıfır veya daha fazla çıktıya sahip olduğu bir işlemin somutlaştırılmasını temsil ettiği yerlerde yönetilirler. Karışık bir cümle gibi durabilir ancak ilerleyen anlatımlarda bunu daha iyi anlayacağınıza inanıyorum.

TensorFlow’daki kenarlar iki kategoride gruplanabilir. Bir işlemin çıktısının başka bir işlem için girdi haline gelmesinin mümkün olduğu normal kenarlar (aktarım veri yapısı (tensörler)) ve iki düğüm arasındaki bağımlılığı kontrol etmek için kullanılan özel kenarlar (bir düğümün diğerinin bitmesini beklediği işlem sırası).

TensorFlow Basit İfadeler

TensorFlow’un öğelerini tartışmaya geçmeden önce, bir TensorFlow programının neye benzediğine dair bir fikir edinmek için önce TensorFlow ile bir kaç örnek yapmanın yararlı olacağını düşünüyorum.

Basit ifadelerle başlayalım ve bir sebepten dolayı y = 5*x + 13 işlevini TensorFlow tarzında değerlendirmek istediğimizi varsayalım. Basit bir Python kodunda bu işlev şöyle görünür:

x = -2.0
y = 5*x + 13
print y

bu da bize 3.0 sonucunu verir.

Şimdi yukarıdaki ifadeyi TensorFlow terimlerine dönüştürmeye çalışalım.


Sabitler

TensorFlow’da sabitler, (constant(value, dtype=None, shape=None, name='Const', verify_shape=False)) imzasına sahip olan fonksiyon sabiti kullanılarak oluşturulur. Burada value gerçek bir sabit değerdir. Sonraki hesaplamalarda kullanılacak dtype veri türü parametresidir. Örnek vermek gerekirse, float 32/64, int 8/16 örneklerini verebilirim. shape isteğe bağlı boyutlardır. name ise, tensör için isteğe bağlı bir addır ve son parametre de, değerlerin şeklinin doğrulandığını gösteren bir boole‘dur.

Eğer modelinizde belirli değerlere sahip sabitlere ihtiyacınız varsa, constant nesne aşağıdaki örnekte olduğu gibi kullanılabilir:

z = tf.constant(5.2, name="x", dtype=tf.float32)

Değişkenler

TensorFlow’daki değişkenler, oturum boyunca durumu korumak için açıkça başlatılması ve grafik içinde kullanılması gereken tensörleri içeren bellek içi tamponlardır. Yapıcı basitçe çağırılarak değişken hesaplama grafiğine eklenir.

Değişkenler özellikle eğitim modellerine başladığınızda kullanışlıdır ve parametreleri almak ve güncellemek için kullanılırlar. Bir kurucunun bağımsız değişkeni olarak iletilen başlangıç değeri, tensör olarak dönüştürülebilen veya döndürülebilen bir tensörü veya nesneyi temsil eder. Bir değişkeni daha sonra eğitim sürecinde kullanılacak ve yinelemeler üzerinden güncellenen bazı önceden tanımlanmış veya rastgele değerlerle doldurmak istiyorsak, bunu aşağıda yer alan komutla tanımlayabiliriz:

k = tf.Variable(tf.zeros([1]), name="k")

TensorFlow’da değişkenleri kullanmanın başka bir yolu da, bu değişkenin eğitilemediği ve aşağıdaki şekilde tanımlanabildiği hesaplamalardır:

k = tf.Variable(tf.add(a, b), trainable=False)

Oturumlar

Düğümleri gerçekten değerlendirmek için, bir oturum içinde hesaplama grafiği çalıştırmalıyız. Bir oturum, TensorFlow çalışma zamanının kontrolünü ve durumunu içerir. Parametrelerin olmadığı bir oturum, geçerli oturumda oluşturulan varsayılan grafiği kullanacaktır, aksi takdirde oturum sınıfı, yürütülecek oturumda kullanılan bir grafik parametresini kabul eder. Aşağıda, yukarıda tanımlanan terimlerin basit bir doğrusal işlevi hesaplamak için TensorFlow’da nasıl kullanılabileceğini gösteren kısa bir kod parçası bulunmaktadır:

import tensorflow as tf

x = tf.constant(-2.0, name="x", dtype=tf.float32)
a = tf.constant(5.0, name="a", dtype=tf.float32)
b = tf.constant(13.0, name="b", dtype=tf.float32)

y = tf.Variable(tf.add(tf.multiply(a, x), b))

init = tf.global_variables_initializer()

with tf.Session() as session:
 session.run(init)
 print session.run(y)

TensorFlow Grafikleri Tanımlama

Veri akışı grafikleriyle çalışmanın iyi yanı, yürütme modelinin, uygulandıktan sonra TensorFlow’daki yazılımın, kodla ilgili tüm karmaşıklığın CPU veya GPU’da kullanılabildiği yürütme modelinden (CPU, GPU veya bazı kombinasyonlarda) ayrı olmasıdır.

Hesaplama grafiği, Graph nesnelerini açık bir şekilde somutlaştırmak zorunda kalmadan TensorFlow kütüphanesini kullanma sürecinde oluşturulabilir.

TensorFlow’daki bir Graph nesnesi, c = tf.add(a, b) gibi basit bir kod satırının sonucu olarak oluşturulabilir. Bu, a ve b toplam sonucunu c çıktısı olarak üreten bir işlem düğümü yaratacaktır. Hesaplama grafiği, Graph nesnesini doğrudan çağırmaya gerek kalmadan kitaplığı kullanan yerleşik bir işlemdir. TensorFlow’da, veri birimleri olarak bir dizi işlem ve tensör içeren bir Graph nesnesi, aynı işleme izin veren ve her grafiğin farklı bir oturuma atanacağı birden fazla grafik içeren işlemler arasında kullanılır.

TensorFlow ayrıca, beslemenin bir işlemin çıktısını tensör değeriyle değiştirdiği grafikteki herhangi bir işleme, bir tensörü patch etmek için besleme mekanizması sağlar. Besleme verileri, run()fonksiyon çağrısında bir argüman olarak aktarılır.

Placeholder, TensorFlow’un geliştiricilerin bazı ifadelerin içine bağlı placeholderlar aracılığıyla hesaplama grafiğine veri eklemelerine izin verme yöntemidir. Placeholder şu şekilde gösterilebilir:

placeholder(dtype, shape=None, name=None)

burada dtype, tensörlerdeki elemanların tipidir ve hem beslenecek tensörlerin şeklini hem de işlemin adını belirtir.

Shape geçilmezse, bu tensör herhangi bir shape ile beslenebilir. Placeholder tensör verilerle beslenmelidir, aksi takdirde, oturumun yürütülmesi üzerine ve bu kısım eksikse, placeholder aşağıdaki yapıda bir hata oluşturur:

InvalidArgumentError (see above for traceback): You must feed a value for placeholder
tensor 'y' with dtype float

Placeholder’ın avantajı, geliştiricilerin önceden veri sağlamaya gerek kalmadan operasyonları ve hesaplama grafiğini oluşturmalarına izin vermesi ve verilerin çalışma zamanında harici kaynaklardan eklenebilmesidir.

Oturum çalıştırma yöntemi aracılığıyla bir placeholder’ın besleme mekanizmasıyla birlikte kullanılacağı, TensorFlow tipinde iki tamsayıyı çarpacak basit bir problemi ele alalım.

import tensorflow as tf

x = tf.placeholder(tf.float32, name="x")
y = tf.placeholder(tf.float32, name="y")
z = tf.multiply(x, y, name="z")

with tf.Session() as session:
 print session.run(z, feed_dict={x: 2.1, y: 3.0})

{' '}

TensorBoard ile Grafiği Görselleştirme

TensorBoard, veri akış grafiklerini analiz etmek için bir görselleştirme aracıdır. Bu, makine öğrenimi modellerini daha iyi anlamak için yararlı olabilir.

TensorBoard ile, genel olarak hesaplama grafiğinin bölümleri, parametreleri, ayrıntıları ve farklı istatistik türleri hakkında fikir edinebilirsiniz. Derin bir sinir ağının çok sayıda düğüme sahip olması alışıldık bir durumdur. TensorBoard, geliştiricilerin her bir düğüm ve hesaplamanın TensorFlow çalışma zamanı üzerinden nasıl yürütüldüğü hakkında bilgi edinmesine olanak tanır.

Şimdi, bu TensorFlow öğreticisinin başında, doğrusal bir fonksiyon tanımladığımız örneğimize geri dönelim y = a*x + b.

Daha sonra TensorFlow, TensorBoard’da kullanılabilen oturumdaki olayları günlüğe kaydetmek için, FileWriter sınıfını sağlayacaktır.

__init__(logdir, graph=None, max_queue=10, flush_secs=120, graph_def=None, filename_suffix=None)

Ve tam olarak örnek kodu şuna benzeyecektir:

import tensorflow as tf

x = tf.constant(-2.0, name="x", dtype=tf.float32)
a = tf.constant(5.0, name="a", dtype=tf.float32)
b = tf.constant(13.0, name="b", dtype=tf.float32)

y = tf.Variable(tf.add(tf.multiply(a, x), b))

init = tf.global_variables_initializer()

with tf.Session() as session:
     merged = tf.summary.merge_all() // new
     writer = tf.summary.FileWriter("logs", session.graph) // new

 session.run(init)
 print session.run(y)

Sadece iki yeni satır ekledik. Varsayılan grafikte toplanan tüm özetleri birleştiririz ve FileWriter sırasıyla yukarıda açıkladığımız gibi olayları dosyaya dökmek için kullanılır.

Programı çalıştırdıktan sonra, dizin günlüklerinde dosyamız oluşacaktır. Son adım olarak tensorboard ‘u da çalıştıralım.

tensorboard --logdir logs/

Artık TensorBoard başlatıldı ve varsayılan bağlantı noktası 6006 olarak belirlendi. http://localhost:6006 url’si ile kontrol edebilirsiniz.

TensorFlow ve Matematik

Tensörler, TensorFlow’daki temel veri yapılarıdır ve bir veri akışı grafiğindeki bağlantı kenarlarını temsil ederler.

Bir tensör basitçe çok boyutlu bir diziyi veya listeyi tanımlar. Tensör yapısı üç parametre ile tanımlanabilir: sıra, şekil ve tür.

  • Derece: Tensörün boyut sayısını belirtir. Bir rank, bir tensörün mertebesi veya n-boyutları olarak bilinir.
  • Şekil: Bir tensörün şekli, sahip olduğu satır ve sütun sayısıdır.
  • Tür: Tensör elemanlarına atanan veri türüdür.

TensorFlow’da tensör oluşturmak için n-boyutlu bir dizi oluşturabiliriz. Bu işlem, NumPy kitaplığını kullanarak veya bir Python n-boyutlu dizisini TensorFlow tensörüne dönüştürerek kolayca yapılabilir.

1-d tensör oluşturmak için, yerleşik bir Python listesini ileterek oluşturacağımız NumPy dizisi kullanacağız.

import numpy as np
tensor_1d = np.array([1.45, -1, 0.2, 102.1])

Bu tür bir diziyle çalışmak, yerleşik bir Python listesiyle çalışmaya benzer. Temel fark, NumPy dizisinin boyut, şekil ve tür gibi bazı ek özellikleri de içermesidir.

> > print tensor1d
[   1.45   -1.      0.2   102.1 ]

> > print tensor1d[0]
1.45

> > print tensor1d[2]
0.2

> > print tensor1d.ndim
1

> > print tensor1d.shape
(4,)

> > print tensor1d.dtype
float64

Bir NumPy dizisi, geliştiricilerin Python nesnelerini tensör nesnelerine dönüştürmesine yardımcı olan convert to tensor yardımcı işlevi ile kolayca bir TensorFlow tensörüne dönüştürülebilir. Bu işlev tensör nesnelerini, NumPy dizilerini, Python listelerini ve Python skalerlerini kabul eder.

tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64)

Şimdi tensörümüzü TensorFlow oturumuna bağlarsak, dönüşümümüzün sonuçlarını görebiliriz.

tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64)

with tf.Session() as session:
 print session.run(tensor)
 print session.run(tensor[0])
 print session.run(tensor[1])

Ve çıktımız şu şekilde olacaktır:

[   1.45   -1.      0.2   102.1 ]
1.45
-1.0

Benzer şekilde 2 boyutlu bir tensör veya matris oluşturabiliriz:

tensor_2d = np.array(np.random.rand(4, 4), dtype='float32')
tensor_2d_1 = np.array(np.random.rand(4, 4), dtype='float32')
tensor_2d_2 = np.array(np.random.rand(4, 4), dtype='float32')

m1 = tf.convert_to_tensor(tensor_2d)
m2 = tf.convert_to_tensor(tensor_2d_1)
m3 = tf.convert_to_tensor(tensor_2d_2)
mat_product = tf.matmul(m1, m2)
mat_sum = tf.add(m2, m3)
mat_det = tf.matrix_determinant(m3)

with tf.Session() as session:
 print session.run(mat_product)
 print session.run(mat_sum)
 print session.run(mat_det)

{' '}

Tensör İşlemleri

Yukarıdaki örnekte, vektörler ve matrisler üzerinde birkaç TensorFlow işlemi gerçekleştirmiş olduk. İşlemler tensörler üzerinde belirli hesaplamalar yapar. Bunun için buradaki linki inceleyebilirsiniz.

Linkte ki tablolarda listelenen TensorFlow işlemleri, tensör nesnelerle çalışır ve eleman bazında gerçekleştirilir. Dolayısıyla, bir x vektörü için kosinüsü hesaplamak isterseniz, TensorFlow işlemi, geçirilen tensördeki her öğe için hesaplamalar yapacaktır.

tensor_1d = np.array([0, 0, 0])
tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64)
with tf.Session() as session:
 print session.run(tf.cos(tensor))

Çıktımız şu şekilde olacaktır:

[ 1.  1.  1.]

Matris İşlemleri

Matris işlemleri, doğrusal regresyon gibi makine öğrenimi modellerinde, sıklıkla kullanıldıkları için çok önemlidir. TensorFlow, çarpma , yer değiştirme, ters çevirme, determinantı hesaplama, doğrusal denklemleri çözme vb. en yaygın matris işlemlerini destekler.

Burada biz de bazı matris işlemlerini açıklayacağız. Şimdi temel matris işlemlerini yapacak bir kod yazalım.

import tensorflow as tf
import numpy as np

def convert(v, t=tf.float32):
 return tf.convert_to_tensor(v, dtype=t)

m1 = convert(np.array(np.random.rand(4, 4), dtype='float32'))
m2 = convert(np.array(np.random.rand(4, 4), dtype='float32'))
m3 = convert(np.array(np.random.rand(4, 4), dtype='float32'))
m4 = convert(np.array(np.random.rand(4, 4), dtype='float32'))
m5 = convert(np.array(np.random.rand(4, 4), dtype='float32'))

m_tranpose = tf.transpose(m1)
m_mul = tf.matmul(m1, m2)
m_det = tf.matrix_determinant(m3)
m_inv = tf.matrix_inverse(m4)
m_solve = tf.matrix_solve(m5, [[1], [1], [1], [1]])

with tf.Session() as session:
 print session.run(m_tranpose)
 print session.run(m_mul)
 print session.run(m_inv)
 print session.run(m_det)
 print session.run(m_solve)

{' '}

Verileri Dönüştürme

{' '}

İndirgeme

TensorFlow, farklı indirgeme türlerini destekler. İndirgeme, bir tensörden bir veya daha fazla boyutu, bu boyutlar arasında belirli işlemleri gerçekleştirerek kaldıran bir işlemdir. Şimdi, örneğimize geçelim:

import tensorflow as tf
import numpy as np

def convert(v, t=tf.float32):
 return tf.convert_to_tensor(v, dtype=t)

x = convert(
 np.array(
     [
         (1, 2, 3),
         (4, 5, 6),
         (7, 8, 9)
     ]), tf.int32)

bool_tensor = convert([(True, False, True), (False, False, True), (True, False, False)], tf.bool)

red_sum_0 = tf.reduce_sum(x)
red_sum = tf.reduce_sum(x, axis=1)

red_prod_0 = tf.reduce_prod(x)
red_prod = tf.reduce_prod(x, axis=1)

red_min_0 = tf.reduce_min(x)
red_min = tf.reduce_min(x, axis=1)

red_max_0 = tf.reduce_max(x)
red_max = tf.reduce_max(x, axis=1)

red_mean_0 = tf.reduce_mean(x)
red_mean = tf.reduce_mean(x, axis=1)

red_bool_all_0 = tf.reduce_all(bool_tensor)
red_bool_all = tf.reduce_all(bool_tensor, axis=1)

red_bool_any_0 = tf.reduce_any(bool_tensor)
red_bool_any = tf.reduce_any(bool_tensor, axis=1)

with tf.Session() as session:
 print "Reduce sum without passed axis parameter: ", session.run(red_sum_0)
 print "Reduce sum with passed axis=1: ", session.run(red_sum)

 print "Reduce product without passed axis parameter: ", session.run(red_prod_0)
 print "Reduce product with passed axis=1: ", session.run(red_prod)

 print "Reduce min without passed axis parameter: ", session.run(red_min_0)
 print "Reduce min with passed axis=1: ", session.run(red_min)

 print "Reduce max without passed axis parameter: ", session.run(red_max_0)
 print "Reduce max with passed axis=1: ", session.run(red_max)

 print "Reduce mean without passed axis parameter: ", session.run(red_mean_0)
 print "Reduce mean with passed axis=1: ", session.run(red_mean)

 print "Reduce bool all without passed axis parameter: ", session.run(red_bool_all_0)
 print "Reduce bool all with passed axis=1: ", session.run(red_bool_all)

 print "Reduce bool any without passed axis parameter: ", session.run(red_bool_any_0)
 print "Reduce bool any with passed axis=1: ", session.run(red_bool_any)

Ve çıktımız şu şekilde olacaktır:

Reduce sum without passed axis parameter:  45
Reduce sum with passed axis=1:  [ 6 15 24]
Reduce product without passed axis parameter:  362880
Reduce product with passed axis=1:  [  6 120 504]
Reduce min without passed axis parameter:  1
Reduce min with passed axis=1:  [1 4 7]
Reduce max without passed axis parameter:  9
Reduce max with passed axis=1:  [3 6 9]
Reduce mean without passed axis parameter:  5
Reduce mean with passed axis=1:  [2 5 8]
Reduce bool all without passed axis parameter:  False
Reduce bool all with passed axis=1:  [False False False]
Reduce bool any without passed axis parameter:  True
Reduce bool any with passed axis=1:  [ True  True  True]

İndirgeme operatörlerinin ilk parametresi, azaltmak istediğimiz tensördür. İkinci parametre, indirgemeyi gerçekleştirmek istediğimiz boyutların indeksleridir. Bu parametre isteğe bağlıdır ve geçilmezse, tüm boyutlar boyunca küçültme gerçekleştirilecektir.

İndirgeme toplamına buradan göz atabilirsiniz. 2 boyutlu bir tensörü geçiyoruz ve onu 1. boyuta indirgemek istiyoruz. Yani bizim durumumuzda ortaya çıkan toplam şu olacaktır:

[1 + 2 + 3 = 6, 4 + 5 + 6 = 15, 7 + 8 + 9 = 24]

0 boyutunu geçersek, sonuç şöyle olur:

[1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 18]

Herhangi bir ekseni geçmezsek, sonuç şunların genel toplamıdır:

1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 45

Tüm indirgeme işlevlerinin benzer bir arabirimi vardır ve TensorFlow indirgeme belgelerinde listelenmiştir.

Segmentasyon

Segmentasyon, boyutlardan birinin boyutları sağlanan segment dizinlerine eşleme işlemi olduğu ve ortaya çıkan öğelerin bir dizin satırı tarafından belirlendiği bir işlemdir.

Segmentasyon aslında öğeleri tekrarlanan dizinler altında gruplandırıyor. Örneğin, bizim durumumuzda, tensör tens1‘e uygulanan [0, 0, 1, 2, 2] kimliklerini bölümlere ayırdık, yani birinci ve ikinci diziler, bölünme işleminden sonra dönüştürülecek (bizim örneğimizden bu işlem toplama olacak) ve (2, 8, 1, 0) = (2+0, 5+3, 3-2, -5+5) şeklinde yeni bir dizi gibi görünecektir. Tensör tens1‘deki üçüncü öğeye dokunulmaz, çünkü tekrarlanan herhangi bir dizinde gruplanmaz ve son iki dizi, birinci grupta olduğu gibi aynı şekilde toplanır.

import tensorflow as tf
import numpy as np

def convert(v, t=tf.float32):
 return tf.convert_to_tensor(v, dtype=t)

seg_ids = tf.constant([0, 0, 1, 2, 2])
tens1 = convert(np.array([(2, 5, 3, -5), (0, 3, -2, 5), (4, 3, 5, 3), (6, 1, 4, 0), (6, 1, 4, 0)]), tf.int32)
tens2 = convert(np.array([1, 2, 3, 4, 5]), tf.int32)

seg_sum = tf.segment_sum(tens1, seg_ids)
seg_sum_1 = tf.segment_sum(tens2, seg_ids)

with tf.Session() as session:
 print "Segmentation sum tens1: ", session.run(seg_sum)
 print "Segmentation sum tens2: ", session.run(seg_sum_1)
Segmentation sum tens1:
[[ 2  8  1  0]
 [ 4  3  5  3]
 [12  2  8  0]]
Segmentation sum tens2: [3 3 9]

Sequence Utilities

Sequence Utilities, aşağıdaki yöntemleri içerir:

  • Giriş tensörünün eksenleri boyunca minimum değerli indeksi döndüren argmin işlevi,
  • Giriş tensörünün eksenleri boyunca maksimum değere sahip dizini döndüren argmax işlevi,
  • iki sayı veya dize listesi arasındaki farkı hesaplayan setdiff ,
  • x veya y öğesinden geçirilen koşula bağlı olan öğeleri döndürecek where işlevi,
  • 1-D tensörde benzersiz öğeler döndürecek unique işlevi.

Aşağıda birkaç uygulama örneği göstermeye çalıştım:

import numpy as np
import tensorflow as tf

def convert(v, t=tf.float32):
 return tf.convert_to_tensor(v, dtype=t)

x = convert(np.array([
     [2, 2, 1, 3],
     [4, 5, 6, -1],
     [0, 1, 1, -2],
     [6, 2, 3, 0]
    ]))

y = convert(np.array([1, 2, 5, 3, 7]))
z = convert(np.array([1, 0, 4, 6, 2]))

arg_min = tf.argmin(x, 1)
arg_max = tf.argmax(x, 1)
unique = tf.unique(y)
diff = tf.setdiff1d(y, z)

with tf.Session() as session:
 print "Argmin = ", session.run(arg_min)
 print "Argmax = ", session.run(arg_max)

 print "Unique_values = ", session.run(unique)[0]
 print "Unique_idx = ", session.run(unique)[1]

 print "Setdiff_values = ", session.run(diff)[0]
 print "Setdiff_idx = ", session.run(diff)[1]

 print session.run(diff)[1]

Ve çıktımız şu şekilde olacaktır:

Argmin = [2 3 3 3]
Argmax =  [3 2 1 0]
Unique_values =  [ 1.  2.  5.  3.  7.]
Unique_idx =  [0 1 2 3 4]
Setdiff_values =  [ 5.  3.  7.]
Setdiff_idx =  [2 3 4]

TensorFlow ile Makine Öğrenimi

Bu bölümde, TensorFlow ile bir makine öğrenimi kullanım örneği sunmaya çalışacağım. İlk örneğimizde, verileri kNN yaklaşımı ile sınıflandırmak için bir algoritma kullanacağız. İkinci örnekte ise doğrusal regresyon algoritmasını kullanmaya çalışacağız.

kNN

İlk kullanacağımız algoritma kNN (k-nearest neighbors algorithm). kNN, verileri eğitime göre sınıflandırmak için Öklid mesafesi gibi mesafe ölçümlerini kullanan denetimli bir öğrenme algoritmasıdır. En basit algoritmalardan biridir, ancak yine de verileri sınıflandırmak için gerçekten güçlüdür. Bu algoritmanın avantajları şunlardır:

  • Eğitim modeli yeterince büyük olduğunda yüksek doğruluk sağlar.
  • Genellikle aykırı değerlere duyarlı değildir ve veriler hakkında herhangi bir varsayımda bulunmamıza gerek yoktur.

Bu algoritmanın dezavantajları ise:

  • Hesaplama açısından maliyetlidir.
  • Yeni sınıflandırılmış verilerin eklenmesi gereken çok fazla bellek gerektirir.

Bu formülde; n, uzayın boyut sayısıdır. x , eğitim verilerinin vektörüdür ve y sınıflandırmak istediğimiz yeni bir veri noktasıdır.

import os
import numpy as np
import tensorflow as tf

ccf_train_data = "train_dataset.csv"
ccf_test_data = "test_dataset.csv"

dataset_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../datasets'))

ccf_train_filepath = os.path.join(dataset_dir, ccf_train_data)
ccf_test_filepath = os.path.join(dataset_dir, ccf_test_data)

def load_data(filepath):
 from numpy import genfromtxt

 csv_data = genfromtxt(filepath, delimiter=",", skip_header=1)
 data = []
 labels = []

 for d in csv_data:
     data.append(d[:-1])
     labels.append(d[-1])

 return np.array(data), np.array(labels)

train_dataset, train_labels = load_data(ccf_train_filepath)
test_dataset, test_labels = load_data(ccf_test_filepath)

train_pl = tf.placeholder("float", [None, 28])
test_pl = tf.placeholder("float", [28])

knn_prediction = tf.reduce_sum(tf.abs(tf.add(train_pl, tf.negative(test_pl))), axis=1)

pred = tf.argmin(knn_prediction, 0)

with tf.Session() as tf_session:
 missed = 0

 for i in xrange(len(test_dataset)):
     knn_index = tf_session.run(pred, feed_dict={train_pl: train_dataset, test_pl: test_dataset[i]})

     print "Predicted class {} -- True class {}".format(train_labels[knn_index], test_labels[i])

     if train_labels[knn_index] != test_labels[i]:
         missed += 1

 tf.summary.FileWriter("../samples/article/logs", tf_session.graph)

print "Missed: {} -- Total: {}".format(missed, len(test_dataset))

Yukarıdaki örnekte kullandığımız veri kümesi, Kaggle veri kümeleri bölümünde bulunabilen bir veri kümesidir. Veri kümesi 31 değişken içerir: Zaman, V1,…, V28, Miktar ve Sınıf. Bu kod örneğinde sadece V1,…, V28 ve Class kullanıyoruz. 1 sahte olanları, o ise olmayanları temsil eden işlem etiketleri görevini görüyor.

Kod örneği, bir veri kümesini yüklemek için işlevi sunduğumuz istisna dışında, çoğunlukla önceki bölümlerde anlattığımız şeyleri içerir. load_data(filepath) işlevi, bağımsız değişken olarak bir CSV dosyası alır ve CSV’de tanımlanan veriler ve etiketlerle bir demet döndürür.

Bu işlevin hemen altında, test ve eğitilmiş veriler için placeholder’lar tanımladık. Tahmin modelinde, sınıflandırılması gereken girdi verilerinin etiketlerini çözmek için eğitilmiş veriler kullanılır. Bizim durumumuzda kNN, en yakın etiketi almak için Öklid mesafesini kullanır.

Hata oranı, bir sınıflandırıcı, -bizim durumumuzda bu veri kümesi için 0.2- toplam örnek sayısını kaçırdığında, sayı ile basit bölme yoluyla hesaplanabilir (yani, sınıflandırıcı bize test verilerinin % 20’si için yanlış veri etiketi verir).

Doğrusal Regresyon

Doğrusal regresyon algoritması, iki değişken arasında doğrusal bir ilişki arar. Bağımlı değişkeni y ve bağımsız değişkeni x olarak etiketlersek, **y = Wx + b** fonksiyonunun parametrelerini tahmin etmeye çalışırız.

Doğrusal regresyon, uygulamalı bilimler alanında yaygın olarak kullanılan bir algoritmadır. Bu algoritma, uygulamaya iki önemli makine öğrenimi kavramının eklenmesine olanak tanır: Loss Function ve işlevin minimumunu bulmak için Gradient Descent.

Bu yöntem kullanılarak uygulanan bir makine öğrenimi algoritması, y‘nin değerlerini x‘in bir fonksiyonu olarak tahmin etmelidir; burada doğrusal bir regresyon algoritması, gerçekte bilinmeyen ve eğitim süreci boyunca belirlenen W ve b değerlerini belirleyecektir. Bir “loss function” seçilir ve genellikle ortalama kare hatası, gradient descent’in, maliyet fonksiyonunun yerel bir minimumunu bulmak için kullanılan optimizasyon algoritması olduğu durumlarda kullanılır.

Gradient descent yöntemi ile yalnızca yerel bir fonksiyon minimumdur, ancak yerel bir minimum bulduktan sonra rastgele yeni bir başlangıç ​​noktası seçerek ve bu işlemi birçok kez tekrarlayarak global bir minimum arayışında kullanılabilir. İşlevin minimum sayısı sınırlıysa ve çok sayıda deneme varsa, bir noktada küresel minimumun tespit edilmesi olasılığı yüksektir.

import tensorflow as tf
import numpy as np

test_data_size = 2000
iterations = 10000
learn_rate = 0.005

def generate_test_values():
     train_x = []
     train_y = []

 for _ in xrange(test_data_size):
     x1 = np.random.rand()
     x2 = np.random.rand()
     x3 = np.random.rand()
     y_f = 2 * x1 + 3 * x2 + 7 * x3 + 4
     train_x.append([x1, x2, x3])
     train_y.append(y_f)

 return np.array(train_x), np.transpose([train_y])

x = tf.placeholder(tf.float32, [None, 3], name="x")
W = tf.Variable(tf.zeros([3, 1]), name="W")
b = tf.Variable(tf.zeros([1]), name="b")
y = tf.placeholder(tf.float32, [None, 1])

model = tf.add(tf.matmul(x, W), b)

cost = tf.reduce_mean(tf.square(y - model))
train = tf.train.GradientDescentOptimizer(learn_rate).minimize(cost)

train_dataset, train_values = generate_test_values()

init = tf.global_variables_initializer()

with tf.Session() as session:
     session.run(init)

    for _ in xrange(iterations):
     session.run(train, feed_dict={
     x: train_dataset,
     y: train_values
     })

    print "cost = {}".format(session.run(cost, feed_dict={
     x: train_dataset,
     y: train_values
     }))

 print "W = {}".format(session.run(W))
 print "b = {}".format(session.run(b))

Ve çıktımız şu şekilde olacaktır:

cost = 3.1083032809e-05
W = [[ 1.99049103]
 [ 2.9887135 ]
 [ 6.98754263]]
b = [ 4.01742554]

Yukarıdaki örnekte, cost ve train dediğimiz iki yeni değişkenimiz var. Bu iki değişkenle, eğitim modelimizde kullanmak istediğimiz bir optimize edici ve en aza indirmek istediğimiz işlevi tanımlamış olduk.

Sonunda, W ve b‘nin çıktı parametreleri, create_test_values işlevinde tanımlananlarla aynı olmalıdır. 17. satırda, aslında w1 = 2, w2 = 3, w3 = 7 ve b = 4 olan doğrusal veri noktalarını oluşturmak için kullandığımız bir fonksiyon tanımladık. Yukarıdaki örnekteki doğrusal regresyon, birden fazla bağımsız değişkenin kullanıldığı çok değişkenlidir.

Sonuç Olarak

Bu TensorFlow makalesinde görebileceğiniz gibi TensorFlow, matematiksel ifadeler ve çok boyutlu dizilerle çalışmayı çocuk oyuncağı haline getiren güçlü bir çerçevedir (ki bu gerçekten makine öğrenimi konusunda ihtiyaç duyduğumuz bir şeydir). Ayrıca, veri grafiklerini yürütme ve ölçeklendirme karmaşıklıklarını da özetler.

Zamanla, TensorFlow popülaritesi arttı ve şimdi geliştiriciler tarafından görüntü tanıma, video algılama, metin işleme gibi derin öğrenme yöntemlerini kullanarak sorunları çözmek için kullanılıyor. Diğer kitaplıklar gibi, TensorFlow’un üzerine kurulu olduğu kavramlara alışmak için biraz zamana ihtiyacınız olabilir. Ve bunu yaptığınızda, dokümantasyon ve topluluk desteğinin yardımıyla, sorunları veri grafikleri olarak temsil etmek ve TensorFlow ile çözmek, makine öğrenimini daha az sıkıcı bir süreç haline getirebilir.

Buraya kadar bana eşlik ettiğiniz için teşekkürler. Sorularınızı sormaktan çekinmeyin.

Sağlıcakla Kalın!

Anatoliacode Makale Aboneliği

Bize abone olarak tüm makaleleri ilk siz okuyabilirsiniz. Ayrıca asla reklam veya spam yapmıyoruz.