TensorFlow'a Başlarken: Bir Makine Öğrenimi Eğitimi

TensorFlow, makine öğrenimi ve derin öğrenme sistemlerini uygulamak için kullanılan, Google tarafından oluşturulan açık kaynaklı bir yazılım kitaplığıdır. Bu iki ad, 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 alacağını öğrenmesini sağlamak için ortak bir zorluğu paylaşan bir dizi güçlü algoritma içerir.

Bu sistemlerle ilgili ayrıntılarla ilgileniyorsanız, makine öğrenimi ve derin öğrenme ile ilgili Toptal blog yazılarından daha fazlasını öğrenebilirsiniz.

TensorFlow, özünde 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 dizileri içeren matematiksel ifadelerle verimli bir şekilde çalışır
• Derin sinir ağları ve makine öğrenimi kavramlarının iyi desteği
• Aynı kodun her iki mimaride de yürütülebildiği GPU/CPU hesaplama
• Makineler ve devasa veri kümeleri arasında yüksek hesaplama ölçeklenebilirliği

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

Bu TensorFlow eğitiminde, TensorFlow'da basit ama güçlü makine öğrenimi yöntemlerini nasıl kullanabileceğinizi ve onunla oluşturulan modellerde hata ayıklamak, görselleştirmek ve ince ayar yapmak için yardımcı kitaplıklarından bazılarını nasıl kullanabileceğinizi öğreneceksiniz.

TensorFlow'u Yükleme

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

TensorFlow'u kurmak için Conda paket bağımlılık yönetim sistemini kullanacağız. Conda, bir makinede birden çok ortamı ayırmamızı sağlar. Conda'nın nasıl kurulacağını buradan öğrenebilirsiniz.

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 yararlı olan NumPy gibi bazı ek kitaplıklarla ortamımızı oluşturacaktır.

Bu ortamın içerisine kurulu olan Python versiyonu 2.7'dir ve biz bu yazımızda bu versiyonu kullanacağız.

 conda create --name TensorflowEnv biopython

İşleri kolaylaştırmak için buraya sadece NumPy yerine biopython kuruyoruz. Buna NumPy ve ihtiyaç duyacağımız diğer birkaç paket dahildir. conda install veya pip install komutlarını kullanarak paketleri her zaman ihtiyaç duyduğunuz şekilde kurabilirsiniz.

Aşağıdaki komut, oluşturulan Conda ortamını etkinleştirecektir. Global olarak kurulan paketlerle veya başka bazı 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. TensorFlow kitaplığını kurmak için kullanacağız. Bunu yapmadan önce, aşağıdaki komutu kullanarak pip'i en son sürüme güncellemek iyi bir ilk adımdır:

 pip install --upgrade pip

Artık aşağıdakileri çalıştırarak TensorFlow'u kurmaya hazırız:

 pip install tensorflow

TensorFlow'un indirilmesi ve oluşturulması birkaç dakika sürebilir. Yazma sırasında bu, TensorFlow 1.1.0'ı yükler.

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, üzerinde işlemlerin gerçekleştirildiği çok boyutlu bir veri kümesidir (tensör).

TensorFlow, hesaplamalı grafiklerle çalıştığından, her bir 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 örneğini temsil ettiği yerlerde yönetilirler.

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 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 bitirmesini beklediği işlem sırası.

Basit İfadeler

TensorFlow öğelerini tartışmaya geçmeden önce, bir TensorFlow programının nasıl göründüğüne dair bir fikir edinmek için ilk olarak TensorFlow ile çalışma oturumu yapacağız.

Basit ifadelerle başlayalım ve bir nedenle y = 5*x + 13 işlevini TensorFlow tarzında değerlendirmek istediğimizi varsayalım.

Basit Python kodunda şöyle görünür:

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

bu da bize bu durumda 3.0 sonucunu verir.

Şimdi yukarıdaki ifadeyi TensorFlow terimlerine çevireceğiz.

sabitler

TensorFlow'da sabitler, imza constant(value, dtype=None, shape=None, name='Const', verify_shape=False) olan işlev sabiti kullanılarak oluşturulur; burada value , kullanılacak gerçek bir sabit değerdir. daha fazla hesaplama, dtype , veri türü parametresidir (örneğin, float32/64, int8/16, vb.), shape isteğe bağlı boyutlardır, name , tensör için isteğe bağlı bir addır ve son parametre, doğrulamanın doğrulandığını gösteren bir boole'dir. değerlerin şekli.

Eğitim 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 grafikte kullanılması gereken tensörleri içeren bellek içi arabelleklerdir. Yalnızca yapıcıyı çağırarak değişken, hesaplama grafiğine eklenir.

Değişkenler özellikle eğitim modelleriyle başladığınızda kullanışlıdır ve parametreleri tutmak ve güncellemek için kullanılırlar. Bir yapıcının argümanı olarak iletilen bir başlangıç ​​değeri, bir tensör olarak dönüştürülebilen veya döndürülebilen bir tensörü veya nesneyi temsil eder. Bu, bir değişkeni eğitim sürecinde daha sonra kullanılacak ve yinelemeler üzerinden güncellenecek önceden tanımlanmış veya rastgele değerlerle doldurmak istiyorsak, onu aşağıdaki şekilde tanımlayabiliriz:

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

Değişkenleri TensorFlow'da kullanmanın başka bir yolu, bu değişkenin eğitilebilir olmadığı ve aşağıdaki şekilde tanımlanabileceğ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 bir hesaplama grafiği çalıştırmalıyız.

Bir oturum, TensorFlow çalışma zamanının kontrolünü ve durumunu kapsar. Parametresiz bir oturum, geçerli oturumda oluşturulan varsayılan grafiği kullanır, aksi takdirde oturum sınıfı, yürütülmek üzere o oturumda kullanılan bir grafik parametresini kabul eder.

Aşağıda, basit bir doğrusal işlevi hesaplamak için TensorFlow'da yukarıda tanımlanan terimlerin nasıl kullanılabileceğini gösteren kısa bir kod parçacığı verilmiştir.

 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'u Kullanma: Hesaplamalı Grafikleri Tanımlama

Veri akışı grafikleriyle çalışmanın iyi yanı, yürütme modelinin yürütülmesinden (CPU, GPU veya bazı kombinasyonlarda) ayrılmasıdır; burada TensorFlow'daki yazılım, bir kez uygulandığında, kodla ilgili tüm karmaşıklığın CPU veya GPU'da kullanılabilir. yürütme gizlidir.

Hesaplama grafiği, Graph nesnelerini açıkça başlatmak zorunda kalmadan TensorFlow kitaplığını kullanma sürecinde oluşturulabilir.

TensorFlow'da bir Graph nesnesi, c = tf.add(a, b) gibi basit bir kod satırının sonucu olarak oluşturulabilir. Bu, toplamlarını c çıktı olarak üreten iki a ve b tensörünü alan bir işlem düğümü yaratacaktır.

Hesaplama grafiği, grafik nesnesini doğrudan çağırmaya gerek kalmadan kitaplığı kullanan yerleşik bir işlemdir. TensorFlow'da bir dizi işlem ve veri birimi olarak tensör içeren bir grafik nesnesi, aynı işleme izin veren işlemler arasında kullanılır ve her grafiğin farklı bir oturuma atanacağı birden fazla grafik içerir. Örneğin, c = tf.add(a, b) kodunun basit satırı, girdi olarak iki a ve b tensörünü alan ve bunların toplamını c çıktı olarak üreten bir işlem düğümü yaratacaktı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 yamalamak için bir besleme mekanizması sağlar. Besleme verileri, run() işlev çağrısında bir argüman olarak iletilir.

Yer tutucu, TensorFlow'un geliştiricilerin bazı ifadelere bağlı yer tutucular aracılığıyla hesaplama grafiğine veri eklemesine izin verme yöntemidir. Yer tutucunun imzası:

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

burada dtype, tensörlerdeki elemanların türüdür ve hem beslenecek tensörlerin şeklini hem de işlemin adını sağlayabilir.

Eğer şekil geçilmezse bu tensör herhangi bir şekil ile beslenebilir. Önemli bir not, yer tutucu tensörünün verilerle beslenmesi gerektiğidir, aksi takdirde, oturumun yürütülmesi üzerine ve bu kısım eksikse, yer tutucu aşağıdaki yapı ile bir hata oluşturur:

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

Yer tutucuların avantajı, geliştiricilerin bunun için önceden veri sağlamaya gerek kalmadan işlemler ve genel olarak hesaplama grafiği oluşturmalarına izin vermeleridir ve veriler çalışma zamanında harici kaynaklardan eklenebilir.

Oturum run yöntemi aracılığıyla bir yer tutucunun bir besleme mekanizmasıyla birlikte kullanılacağı TensorFlow tarzında iki x ve y tamsayısını çarpmanın basit bir problemini 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})

Hesaplamalı Grafiği TensorBoard ile Görselleştirme

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

TensorBoard ile, parametreler hakkında farklı istatistik türleri ve genel olarak hesaplama grafiğinin bölümleriyle ilgili ayrıntılar hakkında fikir edinebilirsiniz. Derin bir sinir ağının çok sayıda düğüme sahip olması alışılmadık bir durum değildir. TensorBoard, geliştiricilerin her bir düğüme ve TensorFlow çalışma zamanı üzerinde hesaplamanın nasıl yürütüldüğüne ilişkin fikir edinmelerine olanak tanır.

Şimdi, y = a*x + b biçiminde doğrusal bir işlev tanımladığımız bu TensorFlow öğreticisinin başlangıcından örneğimize geri dönelim.

Daha sonra TensorBoard'da kullanılabilecek oturumdaki olayları günlüğe kaydetmek için TensorFlow, FileWriter sınıfını sağlar. Oluşturucunun altı parametreyi kabul ettiği ve şöyle göründüğü durumlarda özetleri depolamak için bir olay dosyası oluşturmak için kullanılabilir:

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

logdir parametresinin gerekli olduğu ve diğerlerinin varsayılan değerlere sahip olduğu yerlerde. Grafik parametresi, eğitim programında oluşturulan oturum nesnesinden geçirilecektir. Tam örnek kod şöyle görünü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: 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ştiriyoruz ve sırasıyla yukarıda açıkladığımız gibi olayları dosyaya atmak için FileWriter kullanılıyor.

Programı çalıştırdıktan sonra, dizin günlüklerinde dosyamız var ve son adım tensorboard çalıştırmak:

 tensorboard --logdir logs/

Şimdi TensorBoard başlatıldı ve varsayılan 6006 numaralı bağlantı noktasında çalışıyor. http://localhost:6006 6006'yı açtıktan ve Grafikler menü öğesine (sayfanın en üstünde bulunur) tıkladıktan sonra, grafiği aşağıdaki gibi görebileceksiniz. aşağıdaki resimde:

TensorBoard, aşağıda açıklanan sabitleri ve özet düğümleri belirli sembolleri işaretler.

TensorFlow ile 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, çok boyutlu bir diziyi veya listeyi basitçe tanımlar. Tensör yapısı üç parametre ile tanımlanabilir: sıra, şekil ve tip.

• Rank: Tensörün boyut sayısını tanımlar. Sıra, bir tensörün sırası veya n boyutları olarak bilinir; örneğin, sıra 1 tensör bir vektör veya sıra 2 tensör matristir.
• Şekil: Bir tensörün şekli, sahip olduğu satır ve sütun sayısıdır.
• Tür: Tensör öğelerine atanan veri türü.

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

1 boyutlu bir tensör oluşturmak için yerleşik bir Python listesini ileterek oluşturacağımız bir 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 özellikler 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şleviyle 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])

Çıktı:

 [ 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 tanıtıyoruz. İşlemler, tensörler üzerinde belirli hesaplamalar yapar. Bunların hangi hesaplamalar olduğu aşağıdaki tabloda gösterilmiştir.

Yukarıdaki tabloda listelenen TensorFlow işlemleri, tensör nesneleri ile çalışır ve eleman bazında gerçekleştirilir. Yani bir x vektörü için kosinüs hesaplamak istiyorsanız, TensorFlow işlemi geçen tensördeki her eleman 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ı:

 [ 1. 1. 1.]

Matris İşlemleri

Matris işlemleri, lineer regresyon gibi makine öğrenme modelleri için sıklıkla kullanıldığı için çok önemlidir. TensorFlow, çarpma, yer değiştirme, tersine çevirme, determinantı hesaplama, doğrusal denklemleri çözme ve çok daha fazlası gibi en yaygın matris işlemlerini destekler.

Sırada, bazı matris işlemlerini açıklayacağız. Doğrusal regresyonda olduğu gibi makine öğrenimi modelleri söz konusu olduğunda önemli olma eğilimindedirler. Çarpma, devrik alma, determinant alma, çarpma, sol ve daha pek çok temel matris işlemlerini yapacak bir kod yazalım.

Aşağıda bu işlemleri çağırmanın temel örnekleri verilmiştir.

 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

Kesinti

TensorFlow, farklı türde azaltmaları destekler. İndirgeme, bu boyutlar arasında belirli işlemler gerçekleştirerek bir tensörden bir veya daha fazla boyutu kaldıran bir işlemdir. TensorFlow'un mevcut sürümü için desteklenen indirimlerin bir listesi burada bulunabilir. Aşağıdaki örnekte bunlardan birkaçını sunacağız.

 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)

Çıktı:

 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, küçültmeyi gerçekleştirmek istediğimiz boyutların dizinleridir. Bu parametre isteğe bağlıdır ve geçilmezse tüm boyutlar boyunca küçültme gerçekleştirilir.

Reduce_sum işlemine bir göz atabiliriz. 2 boyutlu bir tensörden geçiyoruz ve onu boyut 1 boyunca küçültmek istiyoruz.

Bizim durumumuzda, elde edilen toplam şöyle 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çemezsek, sonuç yalnızca genel toplamıdır:

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

Tüm azaltma işlevleri benzer bir arayüze sahiptir ve TensorFlow azaltma belgelerinde listelenmiştir.

segmentasyon

Segmentasyon, boyutlardan birinin, boyutların sağlanan segment indeksleri üzerine eşlenmesi süreci olduğu ve ortaya çıkan öğelerin bir indeks satırı tarafından belirlendiği bir işlemdir.

Segmentasyon aslında öğeleri tekrarlanan dizinler altında gruplandırmaktır, bu nedenle, örneğin, bizim durumumuzda, tensör tens1 üzerinde uygulanan segmentli kimlikleri [0, 0, 1, 2, 2] var, yani birinci ve ikinci diziler, segmentasyondan sonra dönüştürülecek işlemi (bizim durumumuzun toplamında) ve (2, 8, 1, 0) = (2+0, 5+3, 3-2, -5+5) gibi görünen yeni bir dizi alacak. Tensör tens1 üçüncü öğeye dokunulmaz çünkü herhangi bir tekrarlanan dizinde gruplanmaz ve son iki dizi, ilk grup için olduğu gibi aynı şekilde toplanır. Toplamın yanı sıra, TensorFlow ürün, ortalama, maks ve min'i destekler.

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]

Sıra Yardımcı Programları

Sıra yardımcı programları aşağıdaki gibi yöntemleri içerir:

• giriş tensörünün eksenleri boyunca min değerine sahip dizini 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 dizi listesi arasındaki farkı hesaplayan setdiff,
• Burada, geçirilen koşula bağlı olarak, iki geçirilen x veya y öğesinden öğeler döndürecek olan işlev veya
• 1 boyutlu tensörde benzersiz öğeler döndürecek benzersiz işlev.

Aşağıda birkaç yürütme örneği gösteriyoruz:

 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]

Çıktı:

 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 sunacağız. İlk örnek, kNN yaklaşımıyla verileri sınıflandırmak için bir algoritma olacak ve ikincisi, doğrusal regresyon algoritmasını kullanacak.

kNN

İlk algoritma k-En Yakın Komşulardır (kNN). Verileri eğitime göre sınıflandırmak için örneğ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 artıları:

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

Bu algoritmanın eksileri:

• Hesaplamalı olarak pahalı ve
• Tüm ilk eğitim örneklerine yeni sınıflandırılmış verilerin eklenmesi gerektiğinde çok fazla bellek gerektirir.

Bu kod örneğinde kullanacağımız mesafe, iki nokta arasındaki mesafeyi şu şekilde tanımlayan Öklid'dir:

Bu formülde n uzayın boyut sayısı, x eğitim verisinin vektö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 seti, Kaggle veri setleri bölümünde bulunabilen bir veri setidir. Avrupalı ​​kart sahiplerinin kredi kartları ile yapılan işlemleri içeren kartı kullandık. Verileri herhangi bir temizleme veya filtreleme yapmadan kullanıyoruz ve bu veri seti için Kaggle'daki açıklamaya göre oldukça dengesiz. 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. Sınıf, hileli olan işlemleri 1 ve 0 olmayan işlemleri etiketler.

Kod örneği, bir veri kümesi yükleme işlevini tanıttığımız istisna dışında, çoğunlukla önceki bölümlerde tanımladığımız şeyleri içerir. load_data(filepath) işlevi, argüman olarak bir CSV dosyası alacak ve CSV'de tanımlanmış veri ve etiketler içeren bir demet döndürecektir.

Bu fonksiyonun hemen altında, test ve eğitilmiş veriler için yer tutucular tanımladık. Eğitilmiş veriler, sınıflandırılması gereken girdi verilerinin etiketlerini çözmek için tahmin modelinde kullanılır. Bizim durumumuzda, kNN en yakın etiketi elde etmek için Öklid mesafesini kullanır.

Hata oranı, bizim durumumuzda bu veri seti için 0.2 olan toplam örnek sayısı tarafından bir sınıflandırıcının kaçırdığı sayı ile basit bölme ile 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ışıyoruz.

Doğrusal regresyon, uygulamalı bilimler alanında yaygın olarak kullanılan bir algoritmadır. Bu algoritma, uygulamada iki önemli makine öğrenimi kavramının eklenmesine izin verir: Maliyet fonksiyonu ve fonksiyonun minimumunu bulmak için gradyan iniş yöntemi.

Bu yöntemi kullanarak uygulanan bir makine öğrenimi algoritması, y değerlerini x 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 maliyet fonksiyonu seçilir ve gradyan inişinin maliyet fonksiyonunun yerel bir minimumunu bulmak için kullanılan optimizasyon algoritması olduğu durumlarda genellikle ortalama kare hatası kullanılır.

Gradyan iniş yöntemi yalnızca yerel bir minimum fonksiyondur, ancak yerel bir minimum bulduğunda rastgele yeni bir başlangıç ​​noktası seçerek ve bu işlemi birçok kez tekrarlayarak global minimum arayışında kullanılabilir. Eğer fonksiyonun minimum sayısı sınırlıysa ve çok sayıda deneme varsa, o zaman bir noktada global minimumun tespit edilmesi için iyi bir şans vardır. Giriş bölümünde bahsettiğimiz makale için bu teknik hakkında biraz daha ayrıntı bırakacağız.

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

Çıktı:

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

Yukarıdaki örnekte, cost ve train adını verdiğimiz iki yeni değişkenimiz var. Bu iki değişken ile eğitim modelimizde kullanmak istediğimiz bir optimizer ve minimize etmek istediğimiz fonksiyonu tanımladık.

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

Çözüm

Bu TensorFlow eğitiminde görebileceğiniz gibi, TensorFlow, matematiksel ifadeler ve çok boyutlu dizilerle çalışmayı çok kolay hale getiren güçlü bir çerçevedir; bu, makine öğreniminde temel olarak gerekli bir şeydir. Ayrıca veri grafiklerini yürütmenin ve ölçeklendirmenin karmaşıklığını da ortadan kaldırır.

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