tensorflow
प्लेसहोल्डर

पैरामीटर

प्लेसहोल्डर्स की मूल बातें

प्लेसहोल्डर आपको टेंसरफ़्लो ग्राफ़ में मानों को खिलाने की अनुमति देता है। आदर्श रूप से वे आपको खिलाए जाने वाले मूल्यों के आयाम और डेटा प्रकार के बारे में बाधाओं को निर्दिष्ट करने की अनुमति देते हैं। इस तरह वे उपयोगी होते हैं जब नए प्रशिक्षण उदाहरणों को खिलाने के लिए एक तंत्रिका नेटवर्क बनाते हैं।

निम्नलिखित उदाहरण 3 बिट्स के लिए एक प्लेसहोल्डर घोषित करता है जो तत्वों के साथ 4 है (या टाइप किया जा सकता है) 32 बिट फ़्लोट्स।

a = tf.placeholder(tf.float32, shape=[3,4], name='a')

प्लेसहोल्डर अपने आप कोई मान नहीं रखेंगे, इसलिए सत्र चलाते समय उन्हें मूल्यों के साथ खिलाना महत्वपूर्ण है अन्यथा आपको एक त्रुटि संदेश मिलेगा। session.run() feed_dict session.run() , जैसे, कॉल करते समय feed_dict तर्क का उपयोग करके यह किया जा सकता है:

# run the graph up to node b, feeding the placeholder `a` with values in my_array 
session.run(b, feed_dict={a: my_array})

यहाँ एक सरल उदाहरण है, जिसमें किसी स्थान पर रखने वाले को घोषित करने और खिलाने की पूरी प्रक्रिया को दिखाया गया है।

import tensorflow as tf
import numpy as np

# Build a graph
graph = tf.Graph()
with graph.as_default():
    # declare a placeholder that is 3 by 4 of type float32
    a = tf.placeholder(tf.float32, shape=(3, 4), name='a')
    
    # Perform some operation on the placeholder
    b = a * 2
    
# Create an array to be fed to `a`
input_array = np.ones((3,4))

# Create a session, and run the graph
with tf.Session(graph=graph) as session:
    # run the session up to node b, feeding an array of values into a
    output = session.run(b, feed_dict={a: input_array})
    print(output)

प्लेसहोल्डर ने 4 के 4 ऐरे से 3 लेता है, और उस टेंडर को फिर नोड बी पर 2 से गुणा किया जाता है, जो तब रिटर्न करता है और निम्नलिखित प्रिंट करता है:

[[ 2.  2.  2.  2.]
 [ 2.  2.  2.  2.]
 [ 2.  2.  2.  2.]]

डिफ़ॉल्ट के साथ प्लेसहोल्डर

अक्सर एक व्यक्ति एक गहन नेटवर्क प्रशिक्षण के दौरान एक या एक से अधिक सत्यापन बैचों को रुक-रुक कर चलाना चाहता है। आमतौर पर प्रशिक्षण डेटा एक कतार से तंग आ चुके हैं मान्यता डेटा के माध्यम से पारित किया जा सकता है, जबकि feed_dict में पैरामीटर sess.run() । tf.placeholder_with_default() को इस स्थिति में अच्छा काम करने के लिए डिज़ाइन किया गया है:

import numpy as np
import tensorflow as tf

IMG_SIZE = [3, 3]
BATCH_SIZE_TRAIN = 2
BATCH_SIZE_VAL = 1

def get_training_batch(batch_size):
    ''' training data pipeline '''
    image = tf.random_uniform(shape=IMG_SIZE)
    label = tf.random_uniform(shape=[])
    min_after_dequeue = 100
    capacity = min_after_dequeue + 3 * batch_size
    images, labels = tf.train.shuffle_batch(
        [image, label], batch_size=batch_size, capacity=capacity,
        min_after_dequeue=min_after_dequeue)
    return images, labels

# define the graph
images_train, labels_train = get_training_batch(BATCH_SIZE_TRAIN)
image_batch = tf.placeholder_with_default(images_train, shape=None)
label_batch = tf.placeholder_with_default(labels_train, shape=None)
new_images = tf.mul(image_batch, -1)
new_labels = tf.mul(label_batch, -1)

# start a session
with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(sess=sess, coord=coord)

    # typical training step where batch data are drawn from the training queue
    py_images, py_labels = sess.run([new_images, new_labels])
    print('Data from queue:')
    print('Images: ', py_images)  # returned values in range [-1.0, 0.0]
    print('\nLabels: ', py_labels) # returned values [-1, 0.0]

    # typical validation step where batch data are supplied through feed_dict
    images_val = np.random.randint(0, 100, size=np.hstack((BATCH_SIZE_VAL, IMG_SIZE)))
    labels_val = np.ones(BATCH_SIZE_VAL)
    py_images, py_labels = sess.run([new_images, new_labels],
                      feed_dict={image_batch:images_val, label_batch:labels_val})
    print('\n\nData from feed_dict:')
    print('Images: ', py_images) # returned values are integers in range [-100.0, 0.0]
    print('\nLabels: ', py_labels) # returned values are -1.0

    coord.request_stop()
    coord.join(threads)

इस उदाहरण में image_batch और label_batch get_training_batch() द्वारा उत्पन्न किए get_training_batch() जब तक कि संबंधित मानों को sess.run() कॉल के दौरान feed_dict पैरामीटर के रूप में पारित नहीं किया जाता है।