ความแตกต่างระหว่าง tf.placeholder กับ tf.Variable คืออะไร

ฉันเป็นมือใหม่กับ TensorFlow ฉันสับสนเกี่ยวกับความแตกต่างระหว่างและtf.placeholder tf.Variableในมุมมองของฉันtf.placeholderใช้สำหรับข้อมูลอินพุตและtf.Variableใช้เพื่อเก็บสถานะของข้อมูล นี่คือทั้งหมดที่ฉันรู้

มีคนอธิบายให้ฉันอย่างละเอียดมากขึ้นเกี่ยวกับความแตกต่างของพวกเขาได้ไหม โดยเฉพาะเมื่อใช้tf.Variableและเมื่อใช้tf.placeholder?

กล่าวโดยย่อคือคุณใช้tf.Variableสำหรับตัวแปรที่ฝึกอบรมได้เช่นน้ำหนัก (W) และอคติ (B) สำหรับแบบจำลองของคุณ

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 ใช้สำหรับป้อนตัวอย่างการฝึกอบรมจริง

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

นี่คือวิธีที่คุณป้อนตัวอย่างการฝึกอบรมระหว่างการฝึก:

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)

ของคุณ tf.variablesจะได้รับการฝึกอบรม (แก้ไข) อันเป็นผลมาจากการฝึกอบรมนี้

ดูเพิ่มเติมได้ที่https://www.tensorflow.org/versions/r0.7/tutorials/mnist/tf/index.html (ตัวอย่างนำมาจากหน้าเว็บ)

ความแตกต่างคือเมื่อtf.Variableคุณต้องระบุค่าเริ่มต้นเมื่อคุณประกาศ ด้วยtf.placeholderคุณไม่จำเป็นต้องให้ค่าเริ่มต้นและคุณสามารถระบุได้ในเวลาทำงานกับfeed_dictอาร์กิวเมนต์ภายในSession.run

เนื่องจากการคำนวณ Tensor ประกอบด้วยกราฟดังนั้นจึงเป็นการดีกว่าที่จะตีความทั้งสองในแง่ของกราฟ

ยกตัวอย่างการถดถอยเชิงเส้นอย่างง่าย

WX+B=Y

ที่WและBยืนสำหรับน้ำหนักและอคติและXสำหรับปัจจัยการสังเกตและYสำหรับการสังเกต' ผลลัพธ์

เห็นได้ชัดXและYมีลักษณะเดียวกัน (ตัวแปรรายการ) ซึ่งแตกต่างจากของWและB(ตัวแปรแฝง) XและYจะมีค่าของกลุ่มตัวอย่าง (สังเกต) และด้วยเหตุนี้จำเป็นต้องมีสถานที่ที่จะเต็มไปขณะที่WและBมีน้ำหนักและอคติตัวแปร (ค่าก่อนหน้านี้ส่งผลกระทบต่อหลัง) ในกราฟซึ่งควรได้รับการอบรมการใช้ที่แตกต่างกันXและYคู่ เราวางตัวอย่างแตกต่างกันไปยึดตำแหน่งในการฝึกอบรมตัวแปร

เราจะต้องบันทึกหรือเรียกคืนตัวแปร (ที่จุดตรวจ) เพื่อบันทึกหรือสร้างกราฟที่มีรหัส

ตัวยึดตำแหน่งเป็นส่วนใหญ่สำหรับชุดข้อมูลที่แตกต่างกัน (เช่นข้อมูลการฝึกอบรมหรือข้อมูลการทดสอบ) อย่างไรก็ตามตัวแปรได้รับการฝึกฝนในกระบวนการฝึกอบรมสำหรับงานเฉพาะเช่นการทำนายผลลัพธ์ของอินพุตหรือแมปอินพุตกับป้ายกำกับที่ต้องการ พวกเขายังคงเหมือนเดิมจนกว่าคุณจะฝึกหรือปรับแต่งรูปแบบการใช้ตัวอย่างแตกต่างกันหรือเหมือนกันในการกรอกข้อมูลลงในตัวยึดมักจะผ่านบริการพจนานุกรม ตัวอย่างเช่น

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

ตัวยึดตำแหน่งจะถูกส่งผ่านเป็นพารามิเตอร์เพื่อตั้งค่ารุ่น

หากคุณเปลี่ยนตัวแทน (เพิ่มลบเปลี่ยนรูปร่าง ฯลฯ ) ของแบบจำลองในระหว่างการฝึกอบรมคุณยังสามารถโหลดจุดตรวจสอบได้โดยไม่ต้องทำการดัดแปลงอื่นใด แต่ถ้าตัวแปรของแบบจำลองที่บันทึกไว้มีการเปลี่ยนแปลงคุณควรปรับจุดตรวจสอบให้สอดคล้องเพื่อโหลดใหม่และดำเนินการฝึกอบรมต่อไป (ตัวแปรทั้งหมดที่กำหนดในกราฟควรมีอยู่ในจุดตรวจสอบ)

ในการสรุปหากค่ามาจากตัวอย่าง (ข้อสังเกตที่คุณมีอยู่แล้ว) คุณจะต้องทำการยึดตำแหน่งไว้อย่างปลอดภัยในขณะที่ถ้าคุณต้องการให้พารามิเตอร์ได้รับการฝึกอบรมให้ใช้ตัวแปรได้ (ใส่เพียงตั้งค่าตัวแปรสำหรับค่าที่คุณต้องการ เพื่อรับ TF โดยอัตโนมัติ)

ในรูปแบบที่น่าสนใจบางอย่างเช่นรูปแบบการถ่ายโอนสไตล์พิกเซลอินพุตจะได้รับการปรับให้เหมาะสมและตัวแปรโมเดลที่ปกติเรียกว่าได้รับการแก้ไขแล้วเราควรสร้างอินพุต

สำหรับข้อมูลเพิ่มเติมโปรดอ่านเอกสารที่เรียบง่ายและมีภาพประกอบนี้

TL; DR

ตัวแปร

• สำหรับพารามิเตอร์ในการเรียนรู้
• ค่าสามารถได้มาจากการฝึกอบรม
• ต้องการค่าเริ่มต้น (มักจะสุ่ม)

ตัวยึด

• พื้นที่เก็บข้อมูลที่จัดสรรสำหรับข้อมูล (เช่นข้อมูลพิกเซลภาพระหว่างฟีด)
• ไม่จำเป็นต้องมีค่าเริ่มต้น (แต่สามารถตั้งค่าดูtf.placeholder_with_default)

ความแตกต่างที่ชัดเจนที่สุดระหว่างtf.Variableและtf.placeholderคือ

คุณใช้ตัวแปรเพื่อเก็บและปรับปรุงพารามิเตอร์ ตัวแปรคือบัฟเฟอร์ในหน่วยความจำที่มีเทนเซอร์ พวกเขาจะต้องเริ่มต้นอย่างชัดเจนและสามารถบันทึกลงดิสก์ในระหว่างและหลังการฝึกอบรม คุณสามารถคืนค่าที่บันทึกไว้เพื่อออกกำลังกายหรือวิเคราะห์แบบจำลองในภายหลัง

sess.run(tf.global_variables_initializer())เริ่มต้นของตัวแปรจะทำกับ ในขณะที่สร้างตัวแปรคุณต้องส่ง Tensor ให้เป็นค่าเริ่มต้นไปยังตัวVariable()สร้างและเมื่อคุณสร้างตัวแปรคุณจะรู้ถึงรูปร่างของมันเสมอ

คุณไม่สามารถอัปเดตตัวยึดตำแหน่งได้ พวกเขายังไม่ควรที่จะเริ่มต้น sess.run(<op>, {a: <some_val>})แต่เพราะพวกเขามีสัญญาที่จะมีเมตริกซ์ที่คุณจำเป็นต้องให้อาหารค่าลงในพวกเขา และในที่สุดเมื่อเปรียบเทียบกับตัวแปรตัวยึดอาจไม่รู้รูปร่าง คุณสามารถให้ส่วนต่าง ๆ ของส่วนข้อมูลหรือไม่ให้อะไรเลยก็ได้

มีความแตกต่างอื่น ๆ :

• สามารถอัปเดตค่าภายในตัวแปรได้ในระหว่างการปรับให้เหมาะสม
• ตัวแปรที่สามารถใช้ร่วมกันและสามารถที่ไม่ใช่สุวินัย
• ค่าภายในตัวแปรสามารถจัดเก็บได้หลังการฝึกอบรม
• เมื่อตัวแปรถูกสร้างขึ้น3 ops จะถูกเพิ่มลงในกราฟ (ตัวแปร op, initializer op, ops สำหรับค่าเริ่มต้น)
• ตัวยึดเป็นฟังก์ชันตัวแปรเป็นคลาส (ดังนั้นตัวพิมพ์ใหญ่)
• เมื่อคุณใช้ TF ในสภาพแวดล้อมแบบกระจายตัวแปรจะถูกเก็บไว้ในสถานที่พิเศษ ( เซิร์ฟเวอร์พารามิเตอร์ ) และใช้ร่วมกันระหว่างพนักงาน

ส่วนที่น่าสนใจคือไม่เพียงสามารถวางตัวแทน คุณสามารถป้อนค่าเป็นตัวแปรและแม้กระทั่งค่าคงที่

เมื่อเพิ่มคำตอบของผู้อื่นพวกเขาก็อธิบายได้เป็นอย่างดีในการสอน MNISTนี้บนเว็บไซต์ Tensoflow:

เราอธิบายการดำเนินการโต้ตอบเหล่านี้โดยการจัดการตัวแปรสัญลักษณ์ มาสร้างกันเถอะ:

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

xไม่ใช่ค่าเฉพาะ เป็นตัวยึดตำแหน่งค่าที่เราจะป้อนเมื่อเราขอให้ TensorFlow ทำการคำนวณ เราต้องการที่จะสามารถใส่ภาพ MNIST จำนวนเท่าใดก็ได้โดยแต่ละภาพจะถูกปรับเป็นเวกเตอร์ 784 มิติ เราแสดงสิ่งนี้เป็นเมตริกซ์ 2 มิติของตัวเลขจำนวนจุดลอยตัวที่มีรูปร่าง [ไม่มี, 784] (ที่นี่ไม่มีหมายความว่าส่วนข้อมูลมีความยาวเท่าใดก็ได้)

เราต้องการน้ำหนักและอคติสำหรับแบบจำลองของเรา เราสามารถจินตนาการการรักษาเหล่านี้เช่นปัจจัยการผลิตเพิ่มเติม แต่ TensorFlow Variableมีวิธีที่ดียิ่งขึ้นในการจัดการกับมัน A Variableเป็นเมตริกซ์ที่ปรับเปลี่ยนได้ซึ่งอาศัยอยู่ในกราฟของการดำเนินการโต้ตอบของ TensorFlow สามารถใช้และแก้ไขได้โดยการคำนวณ สำหรับแอปพลิเคชันการเรียนรู้ของเครื่องหนึ่งโดยทั่วไปจะมีพารามิเตอร์รุ่นเป็นVariables

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

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

เราสร้างสิ่งเหล่านี้Variableโดยให้tf.Variableค่าเริ่มต้นของVariable: ในกรณีนี้เราเริ่มต้นทั้งสองWและbเป็นเทนเซอร์ที่เต็มไปด้วยเลขศูนย์ เนื่องจากเรากำลังจะเรียนรู้Wและbมันไม่สำคัญว่าพวกเขาจะเป็นอะไรในตอนแรก

Tensorflow ใช้คอนเทนเนอร์สามประเภทเพื่อจัดเก็บ / ดำเนินการตามกระบวนการ

1. ค่าคงที่: ค่าคงที่เก็บข้อมูลทั่วไป

2. ตัวแปร: ค่าข้อมูลจะเปลี่ยนไปตามฟังก์ชั่นที่เกี่ยวข้องเช่น cost_function ..

3. ตัวยึดตำแหน่ง: ข้อมูลการฝึกอบรม / การทดสอบจะถูกส่งผ่านไปยังกราฟ

ตัวอย่างข้อมูล:

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

ในฐานะที่เป็นชื่อที่บอกว่าตัวยึดตำแหน่งเป็นสัญญาว่าจะให้ค่าในภายหลังคือ

ตัวแปรเป็นเพียงพารามิเตอร์การฝึกอบรม ( W(เมทริกซ์), b(อคติ) เหมือนกับตัวแปรปกติที่คุณใช้ในการเขียนโปรแกรมแบบวันต่อวันซึ่งผู้ฝึกสอนจะอัปเดต / แก้ไขในแต่ละการวิ่ง / ขั้นตอน

ในขณะที่ตัวยึดตำแหน่งไม่ต้องการค่าเริ่มต้นใด ๆ ที่เมื่อคุณสร้างxและyTF ไม่ได้จัดสรรหน่วยความจำใด ๆ แทนในภายหลังเมื่อคุณป้อนตัวยึดตำแหน่งในการsess.run()ใช้feed_dictงาน TensorFlow จะจัดสรรหน่วยความจำขนาดที่เหมาะสมสำหรับพวกเขา ( xและy ) ness ช่วยให้เราสามารถป้อนขนาดและรูปร่างของข้อมูลได้

โดยสรุป :

ตัวแปร - เป็นพารามิเตอร์ที่คุณต้องการให้ผู้ฝึกสอน (เช่น GradientDescentOptimizer) เพื่ออัปเดตหลังจากแต่ละขั้นตอน

ตัวยึดตำแหน่ง -

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

การดำเนินการ:

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

ทำให้เกิดผลลัพธ์

7.5
[ 3.  7.]

ในกรณีแรก 3 และ 4.5 ​​จะถูกส่งผ่านไปยังaและbตามลำดับจากนั้นไปที่ adder_node ouputting 7 ในกรณีที่สองมีรายการฟีดจะมีการเพิ่มขั้นตอนแรก 1 และ 2 ถัดไป 3 และ 4 ( aและb)

อ่านที่เกี่ยวข้อง:

• tf.placeholder doc
• tf.Variable doc
• ตัวยึด VS ที่เปลี่ยนแปลงได้

ตัวแปร

ตัวแปร TensorFlow เป็นวิธีที่ดีที่สุดในการแสดงสถานะแบบแบ่งใช้ที่คงอยู่ซึ่งจัดการโดยโปรแกรมของคุณ ตัวแปรถูกจัดการผ่านคลาส tf.Variable ภายใน tf.Variable จะเก็บเมตริกซ์ถาวร การดำเนินการเฉพาะช่วยให้คุณสามารถอ่านและแก้ไขค่าของเมตริกซ์นี้ การแก้ไขเหล่านี้สามารถมองเห็นได้ในหลาย ๆ tf.Sessions ดังนั้นคนงานหลายคนสามารถเห็นค่าเดียวกันสำหรับ tf.Variable ตัวแปรจะต้องเริ่มต้นก่อนที่จะใช้

ตัวอย่าง:

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

สิ่งนี้จะสร้างกราฟการคำนวณ ตัวแปร (x และ y) สามารถเริ่มต้นได้และฟังก์ชั่น (f) ประเมินในเซสชั่นเทนเซอร์โฟลว์ดังนี้

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

ตัวยึด

ตัวยึดตำแหน่งเป็นโหนด (เช่นเดียวกับตัวแปร) ที่มีค่าสามารถเริ่มต้นได้ในอนาคต โหนดเหล่านี้โดยทั่วไปจะส่งออกค่าที่กำหนดให้พวกเขาในช่วงรันไทม์ โหนดตัวยึดสามารถกำหนดโดยใช้คลาส tf.placeholder () ซึ่งคุณสามารถระบุอาร์กิวเมนต์เช่นชนิดของตัวแปรและ / หรือรูปร่าง ตัวยึดตำแหน่งถูกใช้อย่างกว้างขวางเพื่อแสดงชุดข้อมูลการฝึกอบรมในรูปแบบการเรียนรู้ของเครื่องเนื่องจากชุดข้อมูลการฝึกอบรมมีการเปลี่ยนแปลงอยู่ตลอดเวลา

ตัวอย่าง:

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

หมายเหตุ: 'ไม่มี' สำหรับส่วนข้อมูลหมายถึง 'ขนาดใดก็ได้'

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.]]

อ้างอิง:

1. https://www.tensorflow.org/guide/variables
2. https://www.tensorflow.org/api_docs/python/tf/placeholder
3. O'Reilly: การเรียนรู้ด้วยเครื่องบนมือด้วย Scikit-Learn & Tensorflow

คิดว่าVariableใน tensorflow เป็นตัวแปรปกติที่เราใช้ในการเขียนโปรแกรมภาษา เราเริ่มต้นตัวแปรเราสามารถแก้ไขได้ในภายหลังเช่นกัน ในขณะที่placeholderไม่ต้องการค่าเริ่มต้น ตัวยึดตำแหน่งจัดสรรบล็อกหน่วยความจำสำหรับใช้ในอนาคต ต่อมาเราสามารถใช้ในการฟีดข้อมูลลงในfeed_dict placeholderโดยค่าเริ่มต้นplaceholderมีรูปร่างที่ไม่ จำกัด ซึ่งช่วยให้คุณสามารถดึงเทนเซอร์ของรูปร่างต่าง ๆ ในเซสชัน คุณสามารถสร้างรูปร่างที่มีข้อ จำกัด โดยส่งอาร์กิวเมนต์ตัวเลือก - รูปร่างตามที่ฉันได้ทำด้านล่าง

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

ขณะทำงานของ Machine Learning ส่วนใหญ่เราไม่รู้จำนวนแถว แต่ (สมมติว่า) เรารู้จำนวนของคุณสมบัติหรือคอลัมน์ ในกรณีนั้นเราสามารถใช้ไม่มี

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

ตอนนี้เราสามารถป้อนเมทริกซ์ใด ๆ ด้วย 4 คอลัมน์และจำนวนแถวใด ๆ

นอกจากนี้ตัวยึดตำแหน่งใช้สำหรับข้อมูลอินพุต (เป็นชนิดของตัวแปรที่เราใช้ในการป้อนข้อมูลโมเดลของเรา) โดยที่ตัวแปรเป็นพารามิเตอร์เช่นน้ำหนักที่เราฝึกอบรมเมื่อเวลาผ่านไป

ตัวยึด:

1. ตัวยึดตำแหน่งเป็นเพียงตัวแปรที่เราจะกำหนดข้อมูลให้ในภายหลัง มันช่วยให้เราสามารถสร้างการดำเนินงานของเราและสร้างกราฟการคำนวณของเราโดยไม่จำเป็นต้องใช้ข้อมูล ในคำศัพท์ TensorFlow เราจะป้อนข้อมูลลงในกราฟผ่านตัวยึดตำแหน่งเหล่านี้

2. ไม่จำเป็นต้องมีค่าเริ่มต้น แต่สามารถมีค่าเริ่มต้นได้ tf.placeholder_with_default)

3. เราต้องให้คุณค่าที่ runtime เช่น:

   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

ตัวแปร:

1. ตัวแปร TensorFlow เป็นวิธีที่ดีที่สุดในการแสดงสถานะแบบแบ่งใช้ที่คงอยู่ซึ่งจัดการโดยโปรแกรมของคุณ
2. ตัวแปรถูกจัดการผ่านคลาส tf.Variable tf.Variable แสดงถึงเทนเซอร์ซึ่งสามารถเปลี่ยนค่าได้โดยการเรียกใช้ ops

ตัวอย่าง: tf.Variable("Welcome to tensorflow!!!")

คำตอบที่เข้ากันได้กับ Tensorflow 2.0 : แนวคิดของตัวยึดตำแหน่งtf.placeholderจะไม่พร้อมใช้งานTensorflow 2.x (>= 2.0)ตามค่าเริ่มต้นเนื่องจากโหมดการดำเนินการเริ่มต้นคือการดำเนินการ Eager

อย่างไรก็ตามเราสามารถใช้มันได้หากใช้ในGraph Mode( Disable Eager Execution)

คำสั่งที่เทียบเท่าสำหรับลุยยึดตำแหน่งในรุ่น 2.x tf.compat.v1.placeholderคือ

คำสั่งเทียบเท่าสำหรับตัวแปร TF ในเวอร์ชัน 2.x คือtf.Variableและถ้าคุณต้องการย้ายรหัสจาก 1.x ถึง 2.x คำสั่งเทียบเท่า

tf.compat.v2.Variable.

โปรดอ้างอิงหน้า Tensorflowสำหรับข้อมูลเพิ่มเติมเกี่ยวกับ Tensorflow เวอร์ชัน 2.0

โปรดดูคู่มือการย้ายถิ่นสำหรับข้อมูลเพิ่มเติมเกี่ยวกับการย้ายถิ่นจากรุ่น 1.x ถึง 2.x

คิดว่ากราฟการคำนวณ ในกราฟเช่นนี้เราต้องโหนดการป้อนข้อมูลเพื่อส่งผ่านข้อมูลของเราที่จะกราฟโหนดเหล่านั้นควรจะกำหนดเป็นตัวยึดตำแหน่งในtensorflow

อย่าคิดว่าเป็นโปรแกรมทั่วไปใน Python คุณสามารถเขียนโปรแกรม Python และทำสิ่งเหล่านั้นทั้งหมดที่ผู้ชายอธิบายไว้ในคำตอบอื่น ๆ เพียงแค่ตัวแปร แต่สำหรับการคำนวณกราฟในเทนเซอร์โฟลว์เพื่อดึงข้อมูลของคุณไปยังกราฟคุณต้องกำหนดพยักหน้าเหล่านั้นเป็นตัวยึด