Tf.placeholder ve tf.Variable arasındaki fark nedir?

TensorFlow'a yeni başladım. Ben arasındaki fark hakkında kafam karıştı tf.placeholderve tf.Variable. Benim görüşüme göre, tf.placeholdergiriş verileri tf.Variableiçin kullanılır ve verilerin durumunu saklamak için kullanılır. Tüm bildiğim bu.

Birisi bana farklılıkları hakkında daha ayrıntılı açıklayabilir mi? Özellikle, ne zaman tf.Variableve ne zaman kullanılır tf.placeholder?

Kısacası, tf.Variablemodeliniz için ağırlık (W) ve yanlılık (B) gibi eğitilebilir değişkenler için kullanılır .

weights = tf.Variable(
    tf.truncated_normal([IMAGE_PIXELS, hidden1_units],
                    stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))), name='weights')

biases = tf.Variable(tf.zeros([hidden1_units]), name='biases')

tf.placeholder gerçek eğitim örneklerini beslemek için kullanılır.

images_placeholder = tf.placeholder(tf.float32, shape=(batch_size, IMAGE_PIXELS))
labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size))

Eğitim sırasında egzersiz örneklerini şu şekilde beslersiniz:

for step in xrange(FLAGS.max_steps):
    feed_dict = {
       images_placeholder: images_feed,
       labels_placeholder: labels_feed,
     }
    _, loss_value = sess.run([train_op, loss], feed_dict=feed_dict)

Sizin tf.variables bu eğitimin sonucunda eğitimli (değiştirilmiş) alınacaktır.

Https://www.tensorflow.org/versions/r0.7/tutorials/mnist/tf/index.html adresinde daha fazla bilgi bulabilirsiniz . (Örnekler web sayfasından alınmıştır.)

Fark, tf.Variablebeyan ettiğinizde sizinle birlikte bir başlangıç ​​değeri sağlamanız gerektiğidir. İle tf.placeholderbir başlangıç değeri sağlamak gerekmez ve birlikte çalışma zamanında belirtebilirsiniz feed_dictargüman içSession.run

Tensör hesaplamaları grafikler oluşturduğundan , ikisini grafikler açısından yorumlamak daha iyidir.

Örneğin basit doğrusal regresyonu ele alalım

WX+B=Y

ağırlıkların ve yanlılığın ve gözlemlerin girdilerinin ve gözlemlerin çıktılarının nerede Wve nerede Bdurduğunu gösterir .XY

Açıkçası Xve ve (gizli değişkenler) ' Yden farklı olan aynı yapıdadır (tezahür değişkenleri). ve örnekleri (gözlem) ve bu nedenle bir ihtiyaç değerleri vardır yer doldurulacak ise ve ağırlıkları ve önyargı vardır değişkenler farklı kullanılarak eğitimli olmalıdır grafikte (önceki değerler ikinci etkiler) ve çiftleri. Değişkenleri eğitmek için Yer Tutuculara farklı örnekler yerleştiriyoruz . WBXYWBXY

Biz sadece gereken kaydetmek veya geri Değişkenler (kontrol noktalarında) kaydetmek veya koduyla grafiği yeniden.

Yer tutucular çoğunlukla farklı veri kümeleri için sahiplerdir (örneğin eğitim verileri veya test verileri). Bununla birlikte, Değişkenler belirli görevler için eğitim sürecinde eğitilir, yani girdinin sonucunu tahmin etmek veya girdileri istenen etiketlerle eşleştirmek için. Sıklıkla dikte yoluyla Yer Tutucular'a doldurmak için farklı veya aynı örnekleri kullanarak modeli yeniden eğitene veya ince ayar yapana kadar aynı kalırlar . Örneğin:

 session.run(a_graph, dict = {a_placeholder_name : sample_values}) 

Yer tutucular ayrıca modelleri ayarlamak için parametre olarak iletilir.

Eğitimin ortasında bir modelin yer tutucularını değiştirirseniz (ekleme, silme, şekil vb. Değiştirme), başka bir değişiklik yapmadan kontrol noktasını yeniden yükleyebilirsiniz. Ancak kaydedilen bir modelin değişkenleri değiştirilirse, kontrol noktasını yeniden yüklemek ve eğitime devam etmek için buna göre ayarlamanız gerekir (grafikte tanımlanan tüm değişkenler kontrol noktasında mevcut olmalıdır).

Özetle, değerler örneklerden (zaten sahip olduğunuz gözlemler) ise, bunları tutmak için güvenli bir yer tutucu yaparsınız, eğitilecek bir parametreye ihtiyacınız varsa bir Değişken (basitçe söylemek gerekirse, istediğiniz değerler için Değişkenleri ayarlayın) TF'yi otomatik olarak kullanmak için).

Bir stil transfer modeli gibi bazı ilginç modellerde, giriş pikselleri optimize edilecek ve normal olarak adlandırılan model değişkenleri sabitlenecektir, o zaman girdiyi (genellikle rastgele başlatılır) bu bağlantıda uygulanan bir değişken olarak yapmalıyız.

Daha fazla bilgi için lütfen bu basit ve açıklayıcı dokümanı belirtiniz .

TL; DR

Değişkenler

• Parametrelerin öğrenilmesi için
• Değerler eğitimden elde edilebilir
• Başlangıç ​​değerleri gerekli (genellikle rastgele)

Yer tutucular

• Veriler için ayrılan depolama alanı (örneğin, feed sırasında görüntü pikseli verileri için)
• Başlangıç ​​değerleri gerekli değildir (ancak ayarlanabilir, bkz. tf.placeholder_with_default)

Arasındaki en belirgin fark tf.Variable ve tf.placeholder olmasıdır

parametreleri tutmak ve güncellemek için değişkenleri kullanırsınız. Değişkenler, tensörler içeren bellek içi tamponlardır. Bunlar açıkça başlatılmalıdır ve eğitim sırasında ve sonrasında diske kaydedilebilir. Daha sonra, modeli uygulamak veya analiz etmek için kaydedilen değerleri geri yükleyebilirsiniz.

Değişkenlerin başlatılması ile yapılır sess.run(tf.global_variables_initializer()). Ayrıca bir değişken oluştururken, yapıcıya başlangıç ​​değeri olarak bir Tensör geçirmeniz gerekir Variable()ve bir değişken oluşturduğunuzda her zaman şeklini bilirsiniz.

Öte yandan, yer tutucuyu güncelleyemezsiniz. Ayrıca başlatılmamalılar, ancak bir tensöre sahip olma vaadleri olduğundan, değeri onlara beslemeniz gerekir sess.run(<op>, {a: <some_val>}). Ve sonunda, bir değişkenle karşılaştırıldığında, yer tutucu şekli bilemeyebilir. Boyutların bölümlerini sağlayabilir veya hiçbir şey sağlayamazsınız.

Başka farklılıklar da var:

• değişken içindeki değerler optimizasyonlar sırasında güncellenebilir
• değişkenler paylaşılabilir ve eğitilemez olabilir
• değişkenin içindeki değerler eğitimden sonra saklanabilir
• değişken oluşturulduğunda, bir grafiğe 3 op eklenir (değişken op, başlatıcı op, başlangıç ​​değeri ops)
• placeholder bir işlevdir, Değişken bir sınıftır (dolayısıyla bir büyük harf)
• TF'yi dağıtılmış bir ortamda kullandığınızda, değişkenler özel bir yerde ( parametre sunucusu ) saklanır ve çalışanlar arasında paylaşılır.

İlginç olan nokta, sadece yer tutucuların beslenememesidir. Değeri bir Değişkene ve hatta bir sabite besleyebilirsiniz.

Başkalarının cevaplarına ek olarak , Tensoflow web sitesindeki bu MNIST eğitiminde de çok iyi açıklıyorlar :

Bu etkileşimli işlemleri sembolik değişkenleri manipüle ederek açıklıyoruz. Bir tane oluşturalım:

x = tf.placeholder(tf.float32, [None, 784]),

xbelirli bir değer değil. Bu bir yer tutucu, TensorFlow'dan bir hesaplama çalıştırmasını istediğimizde gireceğimiz bir değer. Her biri 784 boyutlu bir vektöre düzleştirilmiş çok sayıda MNIST görüntüsü girebilmek istiyoruz. Bunu kayan noktalı sayıların 2 boyutlu bir tensörü olarak, bir şekil ile temsil ediyoruz [Yok, 784]. (Burada Hiçbiri, bir boyutun herhangi bir uzunlukta olabileceği anlamına gelir.)

Modelimiz için ağırlıklara ve sapmalara da ihtiyacımız var. Biz ek girişler gibi bu tedavi düşünebiliriz, ama TensorFlow idare daha iyi bir yol var: Variable. A Variable, TensorFlow'un etkileşimli operasyonlar grafiğinde yaşayan değiştirilebilir bir tensördür. Hesaplama tarafından kullanılabilir ve hatta değiştirilebilir. Makine öğrenimi uygulamaları için genellikle model parametreleri vardır Variable.

W = tf.Variable(tf.zeros([784, 10]))

b = tf.Variable(tf.zeros([10]))

Biz bu oluşturmak Variablevererek s tf.Variablebaşlangıç değeri Variable: Bu durumda, her iki başlatmak Wve bsıfırların dolu tensörlerle olarak. Öğreneceğimiz Wve bbaşlangıçta ne oldukları önemli değil.

Tensorflow işlemi saklamak / yürütmek için üç tip kap kullanır

1. Sabitler: Sabitler tipik verileri tutar.

2. değişkenler: Veri değerleri, maliyet_fonksiyonu gibi işlevlerle değiştirilecektir.

3. yer tutucular: Eğitim / Test verileri grafiğe aktarılacaktır.

Örnek pasaj:

import numpy as np
import tensorflow as tf

### Model parameters ###
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)

### Model input and output ###
x = tf.placeholder(tf.float32)
linear_model = W * x + b
y = tf.placeholder(tf.float32)

### loss ###
loss = tf.reduce_sum(tf.square(linear_model - y)) # sum of the squares

### optimizer ###
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)

### training data ###
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]

### training loop ###
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
  sess.run(train, {x:x_train, y:y_train})

Adından da anlaşılacağı gibi, yer tutucu daha sonra bir değer sağlama sözüdür.

Değişken , günlük programlamanızda kullandığınız normal değişkenlerle aynı olan ve eğitimcinin her koşu / adımda güncellediği / değiştirdiği eğitim parametreleri ( W(matris), b(sapma).

İken tutucu herhangi başlangıç değeri gerektirmez, bunu oluştururken xve ysen tutucuları beslerken TF yerine daha sonra herhangi bir bellek tahsis etmez sess.run()kullanarak feed_dictTensorFlow onlara (için uygun boyutta bellek tahsis edecek, xve y) - Bu unconstrained- ness bize herhangi bir boyut ve şekilde veri beslememizi sağlar.

Özetle :

Değişken - her adımdan sonra eğiticinin (yani GradientDescentOptimizer) güncellenmesini istediğiniz bir parametredir.

Yer tutucu demo -

a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b  # + provides a shortcut for tf.add(a, b)

Yürütme:

print(sess.run(adder_node, {a: 3, b:4.5}))
print(sess.run(adder_node, {a: [1,3], b: [2, 4]}))

sonuç ile sonuçlanır

7.5
[ 3.  7.]

İlk durumda 3 ve 4.5 geçilecek ave bbir besleme listesi vardır İkinci durumda 7. ouputting adder_node sonra ve sırasıyla, ilk adım 1 ve 2 bir sonraki, 3 ve 4 (eklenecek ave b).

İlgili okumalar:

• tf . yer tutucu doc.
• Değişken dok .
• Değişken VS yer tutucusu .

Değişkenler

TensorFlow değişkeni, programınız tarafından değiştirilen paylaşılan, kalıcı durumu temsil etmenin en iyi yoludur. Değişkenler tf.Variable sınıfı aracılığıyla manipüle edilir. Dahili olarak, bir tf.Variable kalıcı bir tensörü saklar. Özel işlemler, bu tensörün değerlerini okumanıza ve değiştirmenize olanak tanır. Bu değişiklikler birden fazla tf oturumunda görülebilir, bu nedenle birden fazla işçi bir tf.Variable için aynı değerleri görebilir. Değişkenler kullanılmadan önce başlatılmalıdır.

Misal:

x = tf.Variable(3, name="x")
y = tf.Variable(4, name="y")
f = x*x*y + y + 2

Bu bir hesaplama grafiği oluşturur. (X ve y) değişkenleri başlatılabilir ve (f) fonksiyonu bir tensorflow oturumunda aşağıdaki gibi değerlendirilebilir:

with tf.Session() as sess:
     x.initializer.run()
     y.initializer.run()
     result = f.eval()
print(result)
42

Yer tutucular

Yer tutucu, değeri gelecekte başlatılabilen bir düğümdür (değişkenle aynıdır). Bu düğümler temel olarak çalışma zamanı sırasında kendilerine atanan değeri verir. Değişken türü ve / veya şekli gibi bağımsız değişkenler sağlayabileceğiniz tf.placeholder () sınıfı kullanılarak bir yer tutucu düğüm atanabilir. Yer tutucular, eğitim veri seti değişmeye devam ettikçe, eğitim veri setini bir makine öğrenme modelinde temsil etmek için yaygın olarak kullanılmaktadır.

Misal:

A = tf.placeholder(tf.float32, shape=(None, 3))
B = A + 5

Not: Bir boyut için 'Hiçbiri', 'herhangi bir boyut' anlamına gelir.

with tf.Session as sess:
    B_val_1 = B.eval(feed_dict={A: [[1, 2, 3]]})
    B_val_2 = B.eval(feed_dict={A: [[4, 5, 6], [7, 8, 9]]})

print(B_val_1)
[[6. 7. 8.]]
print(B_val_2)
[[9. 10. 11.]
 [12. 13. 14.]]

Referanslar:

1. https://www.tensorflow.org/guide/variables
2. https://www.tensorflow.org/api_docs/python/tf/placeholder
3. O'Reilly: Scikit-Learn ve Tensorflow ile Uygulamalı Makine Öğrenmesi

VariableTensorflow'da programlama dillerinde kullandığımız normal değişkenler olarak düşünün . Değişkenleri başlatırız, daha sonra da değiştirebiliriz. Oysa placeholderbaşlangıç ​​değeri gerektirmez. Yer tutucu, ileride kullanmak üzere bellek bloğunu ayırır. Daha sonra feed_dictverileri beslemek için kullanabiliriz placeholder. Varsayılan olarak, placeholderbir oturumda farklı şekillerdeki tensörleri beslemenizi sağlayan kısıtlanmamış bir şekle sahiptir. Aşağıda yaptığım gibi isteğe bağlı -shape argümanını ileterek kısıtlı şekil oluşturabilirsiniz.

x = tf.placeholder(tf.float32,(3,4))
y =  x + 2

sess = tf.Session()
print(sess.run(y)) # will cause an error

s = np.random.rand(3,4)
print(sess.run(y, feed_dict={x:s}))

Makine Öğrenimi görevini yaparken, çoğu zaman satır sayısının farkında değiliz, ancak (varsayalım) özelliklerin veya sütunların sayısını biliyoruz. Bu durumda Yok'u kullanabiliriz.

x = tf.placeholder(tf.float32, shape=(None,4))

Şimdi, çalışma zamanında herhangi bir matrisi 4 sütun ve herhangi bir sayıda satırla besleyebiliriz.

Ayrıca, Yer Tutucular girdi verileri için kullanılır (modelimizi beslemek için kullandığımız bir çeşit değişkenlerdir); Değişkenler, zaman içinde antrenman yaptığımız ağırlıklar gibi parametrelerdir.

Yer tutucu :

1. Yer tutucu, daha sonraki bir tarihte veri atayacağımız bir değişkendir. Verilere ihtiyaç duymadan operasyonlarımızı oluşturmamızı ve hesaplama grafiğimizi oluşturmamızı sağlar. TensorFlow terminolojisinde, verileri bu yer tutucular aracılığıyla grafiğe besliyoruz.

2. Başlangıç ​​değerleri gerekli değildir, ancak tf.placeholder_with_default)

3. Çalışma zamanında değer sağlamak zorundayız:

   a = tf.placeholder(tf.int16) // initialize placeholder value
   b = tf.placeholder(tf.int16) // initialize placeholder value
   
   use it using session like :
   
   sess.run(add, feed_dict={a: 2, b: 3}) // this value we have to assign at runtime

Değişken:

1. TensorFlow değişkeni, programınız tarafından değiştirilen paylaşılan, kalıcı durumu temsil etmenin en iyi yoludur.
2. Değişkenler tf.Variable sınıfı aracılığıyla manipüle edilir. Bir tf.Variable değeri ops çalıştırılarak değiştirilebilen bir tensörü temsil eder.

Misal : tf.Variable("Welcome to tensorflow!!!")

Tensorflow 2.0 Uyumlu Yanıt : Varsayılan Yürütme Modu Eager Yürütme olduğundan Yer Tutucu kavramı varsayılan tf.placeholderolarak kullanılamaz Tensorflow 2.x (>= 2.0).

Ancak, Graph Mode( Disable Eager Execution) öğesinde kullanılırsa bunları kullanabiliriz .

TF Placeholder için 2.x sürümünde eşdeğer komuttur tf.compat.v1.placeholder.

TF Değişkeni için Eşdeğer Komut 2.x sürümünde tf.Variableve kodu 1.x'ten 2.x'e geçirmek istiyorsanız, eşdeğer komut

tf.compat.v2.Variable.

Tensorflow Sürüm 2.0 hakkında daha fazla bilgi için lütfen bu Tensorflow Sayfasına bakın .

Sürüm 1.x'den 2.x'e geçiş hakkında daha fazla bilgi için lütfen Taşıma Kılavuzu'na bakın .

Bir hesaplama grafiği düşünün . Böyle bir grafikte, verilerimizi grafiğe aktarmak için bir giriş düğümüne ihtiyacımız var, bu düğümler tensorflow'da Yer Tutucu olarak tanımlanmalıdır .

Python'da genel bir program olarak düşünmeyin. Bir Python programı yazabilir ve diğer değişkenlerde sadece Değişkenler tarafından açıklanan tüm şeyleri yapabilirsiniz, ancak tensorflow'daki hesaplama grafikleri için, verilerinizi grafiğe beslemek için, bu başlıkları Yer Tutucular olarak tanımlamanız gerekir.